/**
 *  iBizSys 5.0 机器人生产代码（不要直接修改当前代码）
 *  http://www.ibizsys.net
 */
package com.sa.litetwo.srv.card.service;


import java.util.ArrayList;
import java.util.List;
import java.util.HashMap;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.stereotype.Component;
import net.ibizsys.paas.exception.ErrorException;
import net.ibizsys.paas.core.PluginActionResult;
import net.ibizsys.paas.core.IDataEntity;
import net.ibizsys.paas.core.IDEDataSetFetchContext;
import net.ibizsys.paas.db.DBCallResult;
import net.ibizsys.paas.db.DBFetchResult;
import net.ibizsys.paas.db.IProcParam;
import net.ibizsys.paas.util.StringHelper;
import net.ibizsys.paas.util.StringBuilderEx;
import net.ibizsys.paas.core.Errors;
import net.ibizsys.paas.core.ActionContext;
import net.ibizsys.paas.data.DataObject;
import net.ibizsys.paas.service.ServiceGlobal;
import net.ibizsys.paas.entity.IEntity;
import net.ibizsys.paas.demodel.IDataEntityModel;
import net.ibizsys.paas.demodel.DEModelGlobal;
import net.ibizsys.paas.demodel.IDELogicModel;
import net.ibizsys.paas.dao.DAOGlobal;
import net.ibizsys.paas.web.WebContext;
import net.ibizsys.paas.service.IService;
import net.ibizsys.paas.util.DataTypeHelper;
import net.ibizsys.paas.util.KeyValueHelper;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import net.ibizsys.paas.db.SelectCond;
import net.ibizsys.paas.service.IServiceWork;
import net.ibizsys.paas.service.IServicePlugin;
import net.ibizsys.paas.service.ITransaction;
import net.ibizsys.paas.dao.IDAO;
import net.ibizsys.paas.service.CloneSession;
import net.ibizsys.paas.service.ServiceBase;
import net.ibizsys.paas.entity.EntityFieldError;
import net.ibizsys.paas.entity.EntityError;
import java.sql.Timestamp;
import net.ibizsys.paas.util.DefaultValueHelper;
import javax.annotation.PostConstruct;
import net.ibizsys.paas.service.IDataContextParam;
import net.sf.json.JSONObject;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;


import com.sa.litetwo.srv.card.service.GG_EDUService;
import com.sa.litetwo.srv.card.entity.GG_EDU;
import com.sa.litetwo.srv.card.service.GG_GRDHONORService;
import com.sa.litetwo.srv.card.entity.GG_GRDHONOR;
import com.sa.litetwo.srv.card.service.GG_CERTIFService;
import com.sa.litetwo.srv.card.entity.GG_CERTIF;
import com.sa.litetwo.srv.card.service.GG_GRDPOSTService;
import com.sa.litetwo.srv.card.entity.GG_GRDPOST;
import com.sa.litetwo.srv.card.service.GG_SKILLService;
import com.sa.litetwo.srv.card.entity.GG_SKILL;
import com.sa.litetwo.srv.card.service.GG_ATTACHService;
import com.sa.litetwo.srv.card.entity.GG_ATTACH;
import com.sa.litetwo.srv.card.service.GG_TRAINService;
import com.sa.litetwo.srv.card.entity.GG_TRAIN;
import com.sa.litetwo.srv.card.service.GG_WORKService;
import com.sa.litetwo.srv.card.entity.GG_WORK;
import com.sa.litetwo.srv.card.service.GG_PROJService;
import com.sa.litetwo.srv.card.entity.GG_PROJ;
import com.sa.litetwo.srv.card.service.GG_OTHERService;
import com.sa.litetwo.srv.card.entity.GG_OTHER;

import com.sa.litetwo.srv.card.entity.GG_CARD;
import com.sa.litetwo.srv.card.dao.GG_CARDDAO;
import com.sa.litetwo.srv.card.demodel.GG_CARDDEModel;


/**
 * 实体[GG_CARD] 服务对象基类
 */
@Component
public class GG_CARDService extends com.sa.litetwo.srv.liteTwoSysServiceBase<GG_CARD>{
	private static final Log log = LogFactory.getLog(GG_CARDService.class);
	/**
	 * 实体数据集合[DEFAULT]标识
	 */
   public final static String DATASET_DEFAULT = "DEFAULT";


   public GG_CARDService (){
        super();
       
   }

    /**
     * 获取实体[GG_CARD]服务对象
     * @param sessionFactory
     * @return
     * @throws Exception
     */   
    public static GG_CARDService getInstance() throws Exception{
    	return getInstance(null);
    }
    
    /**
     * 获取实体[GG_CARD]服务对象
     * @param sessionFactory
     * @return
     * @throws Exception
     */
    public static GG_CARDService getInstance(SessionFactory sessionFactory) throws Exception{
    	return (GG_CARDService)ServiceGlobal.getService(GG_CARDService.class, sessionFactory);
    }
       
	/**
	 * Spring注册后执行构造处理
	 * @throws Exception
	 */
   @PostConstruct  
   public void postConstruct() throws Exception{    
	   ServiceGlobal.registerService(getServiceId(), this);
   }     
   	
   	/* (non-Javadoc)
	 * @see net.ibizsys.paas.service.ServiceBase#getServiceId()
	 */
   @Override
   protected String getServiceId()
   {
	   return "com.sa.litetwo.srv.card.service.GG_CARDService";
   }

    private GG_CARDDEModel gG_CARDDEModel;
    /**
     * 获取实体[GG_CARD]模型对象
     */
    public  GG_CARDDEModel getGG_CARDDEModel(){
      	if(this.gG_CARDDEModel==null){
                try
                {
                     this.gG_CARDDEModel = (GG_CARDDEModel)DEModelGlobal.getDEModel("com.sa.litetwo.srv.card.demodel.GG_CARDDEModel");
                }
                catch(Exception ex)
                {
                }
            }
           return this.gG_CARDDEModel;
      }
    
    /* (non-Javadoc)
	 * @see net.ibizsys.paas.service.ServiceBase#getDEModel()
	 */
	@Override
   public  IDataEntityModel getDEModel() {
	   return this.getGG_CARDDEModel();
   }
 

   private GG_CARDDAO gG_CARDDAO;

   /**
    * 获取实体[GG_CARD]数据操作对象
    */
     public  GG_CARDDAO getGG_CARDDAO() {
        if(this.gG_CARDDAO==null){
                try
                {
                     this.gG_CARDDAO= (GG_CARDDAO)DAOGlobal.getDAO("com.sa.litetwo.srv.card.dao.GG_CARDDAO",this.getSessionFactory());
                }
                catch(Exception ex)
                {
                }
            }
           return this.gG_CARDDAO;
    }
   
    /* (non-Javadoc)
 	 * @see net.ibizsys.paas.service.IService#getDAO()
 	 */
 	@Override
    public  IDAO getDAO() {
        return this.getGG_CARDDAO();
    }
 	
	/* (non-Javadoc)
	 * @see net.ibizsys.paas.service.ServiceBase#onfetchDataSet(java.lang.String, net.ibizsys.paas.core.IDEDataSetFetchContext)
	 */
    @Override
	protected DBFetchResult onfetchDataSet(String strDataSetName,IDEDataSetFetchContext iDEDataSetFetchContext) throws Exception
	{
              if(StringHelper.compare(strDataSetName,DATASET_DEFAULT,true)==0){
                   return this.fetchDefault(iDEDataSetFetchContext);
              }
              return super.onfetchDataSet(strDataSetName,iDEDataSetFetchContext);
	}

    /**
     * 获取数据集合
   	 * @param strDataSetName
   	 * @param iDEDataSetFetchContext
   	 * @return
   	 * @throws Exception
   	 */
    @Override
   	protected DBFetchResult onfetchDataSetTemp(String strDataSetName,IDEDataSetFetchContext iDEDataSetFetchContext) throws Exception
   	{
         if(StringHelper.compare(strDataSetName,DATASET_DEFAULT,true)==0){
                return this.fetchTempDefault(iDEDataSetFetchContext);
         }
         return super.onfetchDataSetTemp(strDataSetName,iDEDataSetFetchContext);
   	}
	
	/* (non-Javadoc)
	 * @see net.ibizsys.paas.service.ServiceBase#onExecuteAction(java.lang.String, net.ibizsys.paas.entity.IEntity)
	 */
   	@Override
	protected  void onExecuteAction(String strAction,IEntity entity) throws Exception
	{
            super.onExecuteAction(strAction,entity);
	}

    /**
	 * 获取数据集合[DEFAULT]
	 * @param iDEDataSetFetchContext
	 * @return
	 * @throws Exception
	 */
public DBFetchResult fetchDefault(IDEDataSetFetchContext iDEDataSetFetchContext) throws Exception{

    DBFetchResult dbFetchResult =  doServiceFetchWork(iDEDataSetFetchContext,DATASET_DEFAULT,false);
   // dbFetchResult.getDataSet().cacheDataRow();
   // session.close();
    return dbFetchResult;
}

        /**
	 * 获取数据集合[DEFAULT]（临时数据模型）
	 * @param iDEDataSetFetchContext
	 * @return
	 * @throws Exception
	 */
public DBFetchResult fetchTempDefault(IDEDataSetFetchContext iDEDataSetFetchContext) throws Exception{

    DBFetchResult dbFetchResult =  doServiceFetchWork(iDEDataSetFetchContext,DATASET_DEFAULT,true);
    return dbFetchResult;
}





	
	/* (non-Javadoc)
	 * @see net.ibizsys.paas.service.ServiceBase#onFillParentInfo(net.ibizsys.paas.entity.IEntity, java.lang.String, java.lang.String, java.lang.String)
	 */
    @Override
    protected void onFillParentInfo(GG_CARD et,String strParentType,String strTypeParam,String strParentKey) throws Exception
    {
         super.onFillParentInfo(et,strParentType,strTypeParam,strParentKey);
    }
    
    /* (non-Javadoc)
     * @see net.ibizsys.paas.service.ServiceBase#onSyncDER1NData(java.lang.String, java.lang.String, java.lang.String)
     */
    @Override
	protected String onSyncDER1NData(String strDER1NId, String strParentKey, String strDatas) throws Exception
	{
		return super.onSyncDER1NData( strDER1NId,  strParentKey,  strDatas);
	}





	/* (non-Javadoc)
	 * @see net.ibizsys.paas.service.ServiceBase#onFillEntityFullInfo(net.ibizsys.paas.entity.IEntity, boolean)
	 */
    @Override
     protected void onFillEntityFullInfo(GG_CARD et, boolean bCreate) throws Exception
    {
		//填充新建默认值
    	if(bCreate)
    	{
           if(et.getGG_CARDName()==null){
        	   et.setGG_CARDName((String)DefaultValueHelper.getValue(this.getWebContext(),"PARAM","XM",25));
           }
    	}
        super.onFillEntityFullInfo(et, bCreate);

        //填充物理化外键相关属性
    }


	/* (non-Javadoc)
	 * @see net.ibizsys.paas.service.ServiceBase#onWriteBackParent(net.ibizsys.paas.entity.IEntity, boolean)
	 */
	@Override
	protected void onWriteBackParent(GG_CARD et, boolean bCreate) throws Exception
	{
		super.onWriteBackParent(et, bCreate);
	}
	






	/* (non-Javadoc)
	 * @see net.ibizsys.paas.service.ServiceBase#onBeforeRemove(net.ibizsys.paas.entity.IEntity)
	 */
    @Override
    protected void onBeforeRemove(GG_CARD et) throws Exception
    {
        //删除 关系 教育 数据
        if(true)
        {
              GG_EDUService service = (GG_EDUService)ServiceGlobal.getService(GG_EDUService.class,this.getSessionFactory());
              service.testRemoveByCARD(et);
              service.removeByCARD(et);
        }
        //删除 关系 荣誉 数据
        if(true)
        {
              GG_GRDHONORService service = (GG_GRDHONORService)ServiceGlobal.getService(GG_GRDHONORService.class,this.getSessionFactory());
              service.testRemoveByCARD(et);
              service.removeByCARD(et);
        }
        //删除 关系 证书 数据
        if(true)
        {
              GG_CERTIFService service = (GG_CERTIFService)ServiceGlobal.getService(GG_CERTIFService.class,this.getSessionFactory());
              service.testRemoveByCARD(et);
              service.removeByCARD(et);
        }
        //删除 关系 职务 数据
        if(true)
        {
              GG_GRDPOSTService service = (GG_GRDPOSTService)ServiceGlobal.getService(GG_GRDPOSTService.class,this.getSessionFactory());
              service.testRemoveByCARD(et);
              service.removeByCARD(et);
        }
        //删除 关系 技能 数据
        if(true)
        {
              GG_SKILLService service = (GG_SKILLService)ServiceGlobal.getService(GG_SKILLService.class,this.getSessionFactory());
              service.testRemoveByCARD(et);
              service.removeByCARD(et);
        }
        //删除 关系 附件 数据
        if(true)
        {
              GG_ATTACHService service = (GG_ATTACHService)ServiceGlobal.getService(GG_ATTACHService.class,this.getSessionFactory());
              service.testRemoveByCARD(et);
              service.removeByCARD(et);
        }
        //删除 关系 培训 数据
        if(true)
        {
              GG_TRAINService service = (GG_TRAINService)ServiceGlobal.getService(GG_TRAINService.class,this.getSessionFactory());
              service.testRemoveByCARD(et);
              service.removeByCARD(et);
        }
        //删除 关系 工作 数据
        if(true)
        {
              GG_WORKService service = (GG_WORKService)ServiceGlobal.getService(GG_WORKService.class,this.getSessionFactory());
              service.testRemoveByCARD(et);
              service.removeByCARD(et);
        }
        //删除 关系 项目 数据
        if(true)
        {
              GG_PROJService service = (GG_PROJService)ServiceGlobal.getService(GG_PROJService.class,this.getSessionFactory());
              service.testRemoveByCARD(et);
              service.removeByCARD(et);
        }
        //删除 关系 其他 数据
        if(true)
        {
              GG_OTHERService service = (GG_OTHERService)ServiceGlobal.getService(GG_OTHERService.class,this.getSessionFactory());
              service.testRemoveByCARD(et);
              service.removeByCARD(et);
        }
		super.onBeforeRemove(et);
    }

	/* (non-Javadoc)
	 * @see net.ibizsys.paas.service.ServiceBase#onBeforeRemoveTemp(net.ibizsys.paas.entity.IEntity)
	 */
    @Override
    protected void onBeforeRemoveTemp(GG_CARD et) throws Exception
    {
       //删除 关系 其他 数据
        if(true)
        {
              GG_OTHERService service = (GG_OTHERService)ServiceGlobal.getService(GG_OTHERService.class,this.getSessionFactory());
              service.removeTempByCARD(et);
        }
       //删除 关系 项目 数据
        if(true)
        {
              GG_PROJService service = (GG_PROJService)ServiceGlobal.getService(GG_PROJService.class,this.getSessionFactory());
              service.removeTempByCARD(et);
        }
       //删除 关系 工作 数据
        if(true)
        {
              GG_WORKService service = (GG_WORKService)ServiceGlobal.getService(GG_WORKService.class,this.getSessionFactory());
              service.removeTempByCARD(et);
        }
       //删除 关系 培训 数据
        if(true)
        {
              GG_TRAINService service = (GG_TRAINService)ServiceGlobal.getService(GG_TRAINService.class,this.getSessionFactory());
              service.removeTempByCARD(et);
        }
       //删除 关系 附件 数据
        if(true)
        {
              GG_ATTACHService service = (GG_ATTACHService)ServiceGlobal.getService(GG_ATTACHService.class,this.getSessionFactory());
              service.removeTempByCARD(et);
        }
       //删除 关系 技能 数据
        if(true)
        {
              GG_SKILLService service = (GG_SKILLService)ServiceGlobal.getService(GG_SKILLService.class,this.getSessionFactory());
              service.removeTempByCARD(et);
        }
       //删除 关系 职务 数据
        if(true)
        {
              GG_GRDPOSTService service = (GG_GRDPOSTService)ServiceGlobal.getService(GG_GRDPOSTService.class,this.getSessionFactory());
              service.removeTempByCARD(et);
        }
       //删除 关系 证书 数据
        if(true)
        {
              GG_CERTIFService service = (GG_CERTIFService)ServiceGlobal.getService(GG_CERTIFService.class,this.getSessionFactory());
              service.removeTempByCARD(et);
        }
       //删除 关系 荣誉 数据
        if(true)
        {
              GG_GRDHONORService service = (GG_GRDHONORService)ServiceGlobal.getService(GG_GRDHONORService.class,this.getSessionFactory());
              service.removeTempByCARD(et);
        }
       //删除 关系 教育 数据
        if(true)
        {
              GG_EDUService service = (GG_EDUService)ServiceGlobal.getService(GG_EDUService.class,this.getSessionFactory());
              service.removeTempByCARD(et);
        }
		super.onBeforeRemoveTemp(et);
    }


    @Override
    protected void getRelatedDataTempMajor(GG_CARD et) throws Exception 
   {
       getRelatedDataTempMajor_GG_EDU(et);
       getRelatedDataTempMajor_GG_GRDHONOR(et);
       getRelatedDataTempMajor_GG_CERTIF(et);
       getRelatedDataTempMajor_GG_GRDPOST(et);
       getRelatedDataTempMajor_GG_SKILL(et);
       getRelatedDataTempMajor_GG_ATTACH(et);
       getRelatedDataTempMajor_GG_TRAIN(et);
       getRelatedDataTempMajor_GG_WORK(et);
       getRelatedDataTempMajor_GG_PROJ(et);
       getRelatedDataTempMajor_GG_OTHER(et);
	super.getRelatedDataTempMajor(et);
    }

     protected void getRelatedDataTempMajor_GG_EDU(GG_CARD et) throws Exception 
     {
          com.sa.litetwo.srv.card.service.GG_EDUService service = ( com.sa.litetwo.srv.card.service.GG_EDUService)ServiceGlobal.getService(com.sa.litetwo.srv.card.service.GG_EDUService.class,this.getSessionFactory());
           java.util.ArrayList<com.sa.litetwo.srv.card.entity.GG_EDU> list = null;
           String strKeyValue = et.getGG_CARDId();
           if(strKeyValue.indexOf(TEMPKEY)!=0)
        	   list = service.selectByCARD(et);
           else
        	   list = service.selectTempByCARD(et);
           for(com.sa.litetwo.srv.card.entity.GG_EDU entity:list)
           {
                service.getTempMajor(entity); 
           }
     }
     protected void getRelatedDataTempMajor_GG_GRDHONOR(GG_CARD et) throws Exception 
     {
          com.sa.litetwo.srv.card.service.GG_GRDHONORService service = ( com.sa.litetwo.srv.card.service.GG_GRDHONORService)ServiceGlobal.getService(com.sa.litetwo.srv.card.service.GG_GRDHONORService.class,this.getSessionFactory());
           java.util.ArrayList<com.sa.litetwo.srv.card.entity.GG_GRDHONOR> list = null;
           String strKeyValue = et.getGG_CARDId();
           if(strKeyValue.indexOf(TEMPKEY)!=0)
        	   list = service.selectByCARD(et);
           else
        	   list = service.selectTempByCARD(et);
           for(com.sa.litetwo.srv.card.entity.GG_GRDHONOR entity:list)
           {
                service.getTempMajor(entity); 
           }
     }
     protected void getRelatedDataTempMajor_GG_CERTIF(GG_CARD et) throws Exception 
     {
          com.sa.litetwo.srv.card.service.GG_CERTIFService service = ( com.sa.litetwo.srv.card.service.GG_CERTIFService)ServiceGlobal.getService(com.sa.litetwo.srv.card.service.GG_CERTIFService.class,this.getSessionFactory());
           java.util.ArrayList<com.sa.litetwo.srv.card.entity.GG_CERTIF> list = null;
           String strKeyValue = et.getGG_CARDId();
           if(strKeyValue.indexOf(TEMPKEY)!=0)
        	   list = service.selectByCARD(et);
           else
        	   list = service.selectTempByCARD(et);
           for(com.sa.litetwo.srv.card.entity.GG_CERTIF entity:list)
           {
                service.getTempMajor(entity); 
           }
     }
     protected void getRelatedDataTempMajor_GG_GRDPOST(GG_CARD et) throws Exception 
     {
          com.sa.litetwo.srv.card.service.GG_GRDPOSTService service = ( com.sa.litetwo.srv.card.service.GG_GRDPOSTService)ServiceGlobal.getService(com.sa.litetwo.srv.card.service.GG_GRDPOSTService.class,this.getSessionFactory());
           java.util.ArrayList<com.sa.litetwo.srv.card.entity.GG_GRDPOST> list = null;
           String strKeyValue = et.getGG_CARDId();
           if(strKeyValue.indexOf(TEMPKEY)!=0)
        	   list = service.selectByCARD(et);
           else
        	   list = service.selectTempByCARD(et);
           for(com.sa.litetwo.srv.card.entity.GG_GRDPOST entity:list)
           {
                service.getTempMajor(entity); 
           }
     }
     protected void getRelatedDataTempMajor_GG_SKILL(GG_CARD et) throws Exception 
     {
          com.sa.litetwo.srv.card.service.GG_SKILLService service = ( com.sa.litetwo.srv.card.service.GG_SKILLService)ServiceGlobal.getService(com.sa.litetwo.srv.card.service.GG_SKILLService.class,this.getSessionFactory());
           java.util.ArrayList<com.sa.litetwo.srv.card.entity.GG_SKILL> list = null;
           String strKeyValue = et.getGG_CARDId();
           if(strKeyValue.indexOf(TEMPKEY)!=0)
        	   list = service.selectByCARD(et);
           else
        	   list = service.selectTempByCARD(et);
           for(com.sa.litetwo.srv.card.entity.GG_SKILL entity:list)
           {
                service.getTempMajor(entity); 
           }
     }
     protected void getRelatedDataTempMajor_GG_ATTACH(GG_CARD et) throws Exception 
     {
          com.sa.litetwo.srv.card.service.GG_ATTACHService service = ( com.sa.litetwo.srv.card.service.GG_ATTACHService)ServiceGlobal.getService(com.sa.litetwo.srv.card.service.GG_ATTACHService.class,this.getSessionFactory());
           java.util.ArrayList<com.sa.litetwo.srv.card.entity.GG_ATTACH> list = null;
           String strKeyValue = et.getGG_CARDId();
           if(strKeyValue.indexOf(TEMPKEY)!=0)
        	   list = service.selectByCARD(et);
           else
        	   list = service.selectTempByCARD(et);
           for(com.sa.litetwo.srv.card.entity.GG_ATTACH entity:list)
           {
                service.getTempMajor(entity); 
           }
     }
     protected void getRelatedDataTempMajor_GG_TRAIN(GG_CARD et) throws Exception 
     {
          com.sa.litetwo.srv.card.service.GG_TRAINService service = ( com.sa.litetwo.srv.card.service.GG_TRAINService)ServiceGlobal.getService(com.sa.litetwo.srv.card.service.GG_TRAINService.class,this.getSessionFactory());
           java.util.ArrayList<com.sa.litetwo.srv.card.entity.GG_TRAIN> list = null;
           String strKeyValue = et.getGG_CARDId();
           if(strKeyValue.indexOf(TEMPKEY)!=0)
        	   list = service.selectByCARD(et);
           else
        	   list = service.selectTempByCARD(et);
           for(com.sa.litetwo.srv.card.entity.GG_TRAIN entity:list)
           {
                service.getTempMajor(entity); 
           }
     }
     protected void getRelatedDataTempMajor_GG_WORK(GG_CARD et) throws Exception 
     {
          com.sa.litetwo.srv.card.service.GG_WORKService service = ( com.sa.litetwo.srv.card.service.GG_WORKService)ServiceGlobal.getService(com.sa.litetwo.srv.card.service.GG_WORKService.class,this.getSessionFactory());
           java.util.ArrayList<com.sa.litetwo.srv.card.entity.GG_WORK> list = null;
           String strKeyValue = et.getGG_CARDId();
           if(strKeyValue.indexOf(TEMPKEY)!=0)
        	   list = service.selectByCARD(et);
           else
        	   list = service.selectTempByCARD(et);
           for(com.sa.litetwo.srv.card.entity.GG_WORK entity:list)
           {
                service.getTempMajor(entity); 
           }
     }
     protected void getRelatedDataTempMajor_GG_PROJ(GG_CARD et) throws Exception 
     {
          com.sa.litetwo.srv.card.service.GG_PROJService service = ( com.sa.litetwo.srv.card.service.GG_PROJService)ServiceGlobal.getService(com.sa.litetwo.srv.card.service.GG_PROJService.class,this.getSessionFactory());
           java.util.ArrayList<com.sa.litetwo.srv.card.entity.GG_PROJ> list = null;
           String strKeyValue = et.getGG_CARDId();
           if(strKeyValue.indexOf(TEMPKEY)!=0)
        	   list = service.selectByCARD(et);
           else
        	   list = service.selectTempByCARD(et);
           for(com.sa.litetwo.srv.card.entity.GG_PROJ entity:list)
           {
                service.getTempMajor(entity); 
           }
     }
     protected void getRelatedDataTempMajor_GG_OTHER(GG_CARD et) throws Exception 
     {
          com.sa.litetwo.srv.card.service.GG_OTHERService service = ( com.sa.litetwo.srv.card.service.GG_OTHERService)ServiceGlobal.getService(com.sa.litetwo.srv.card.service.GG_OTHERService.class,this.getSessionFactory());
           java.util.ArrayList<com.sa.litetwo.srv.card.entity.GG_OTHER> list = null;
           String strKeyValue = et.getGG_CARDId();
           if(strKeyValue.indexOf(TEMPKEY)!=0)
        	   list = service.selectByCARD(et);
           else
        	   list = service.selectTempByCARD(et);
           for(com.sa.litetwo.srv.card.entity.GG_OTHER entity:list)
           {
                service.getTempMajor(entity); 
           }
     }


	@Override
	protected void updateRelatedDataTempMajor(GG_CARD tempET,GG_CARD oriET) throws Exception 
	{
	     java.util.ArrayList<com.sa.litetwo.srv.card.entity.GG_OTHER> gG_OTHERlist = updateRelatedDataTempMajor_removeGG_OTHER(tempET,oriET);
	     java.util.ArrayList<com.sa.litetwo.srv.card.entity.GG_PROJ> gG_PROJlist = updateRelatedDataTempMajor_removeGG_PROJ(tempET,oriET);
	     java.util.ArrayList<com.sa.litetwo.srv.card.entity.GG_WORK> gG_WORKlist = updateRelatedDataTempMajor_removeGG_WORK(tempET,oriET);
	     java.util.ArrayList<com.sa.litetwo.srv.card.entity.GG_TRAIN> gG_TRAINlist = updateRelatedDataTempMajor_removeGG_TRAIN(tempET,oriET);
	     java.util.ArrayList<com.sa.litetwo.srv.card.entity.GG_ATTACH> gG_ATTACHlist = updateRelatedDataTempMajor_removeGG_ATTACH(tempET,oriET);
	     java.util.ArrayList<com.sa.litetwo.srv.card.entity.GG_SKILL> gG_SKILLlist = updateRelatedDataTempMajor_removeGG_SKILL(tempET,oriET);
	     java.util.ArrayList<com.sa.litetwo.srv.card.entity.GG_GRDPOST> gG_GRDPOSTlist = updateRelatedDataTempMajor_removeGG_GRDPOST(tempET,oriET);
	     java.util.ArrayList<com.sa.litetwo.srv.card.entity.GG_CERTIF> gG_CERTIFlist = updateRelatedDataTempMajor_removeGG_CERTIF(tempET,oriET);
	     java.util.ArrayList<com.sa.litetwo.srv.card.entity.GG_GRDHONOR> gG_GRDHONORlist = updateRelatedDataTempMajor_removeGG_GRDHONOR(tempET,oriET);
	     java.util.ArrayList<com.sa.litetwo.srv.card.entity.GG_EDU> gG_EDUlist = updateRelatedDataTempMajor_removeGG_EDU(tempET,oriET);
	
	     updateRelatedDataTempMajor_updateGG_EDU(tempET,oriET,gG_EDUlist);
	     updateRelatedDataTempMajor_updateGG_GRDHONOR(tempET,oriET,gG_GRDHONORlist);
	     updateRelatedDataTempMajor_updateGG_CERTIF(tempET,oriET,gG_CERTIFlist);
	     updateRelatedDataTempMajor_updateGG_GRDPOST(tempET,oriET,gG_GRDPOSTlist);
	     updateRelatedDataTempMajor_updateGG_SKILL(tempET,oriET,gG_SKILLlist);
	     updateRelatedDataTempMajor_updateGG_ATTACH(tempET,oriET,gG_ATTACHlist);
	     updateRelatedDataTempMajor_updateGG_TRAIN(tempET,oriET,gG_TRAINlist);
	     updateRelatedDataTempMajor_updateGG_WORK(tempET,oriET,gG_WORKlist);
	     updateRelatedDataTempMajor_updateGG_PROJ(tempET,oriET,gG_PROJlist);
	     updateRelatedDataTempMajor_updateGG_OTHER(tempET,oriET,gG_OTHERlist);
	     super.updateRelatedDataTempMajor(tempET, oriET);
	}


	 protected java.util.ArrayList<com.sa.litetwo.srv.card.entity.GG_EDU> updateRelatedDataTempMajor_removeGG_EDU(GG_CARD tempET,GG_CARD oriET) throws Exception 
	 {
	      com.sa.litetwo.srv.card.service.GG_EDUService service = ( com.sa.litetwo.srv.card.service.GG_EDUService)ServiceGlobal.getService(com.sa.litetwo.srv.card.service.GG_EDUService.class,this.getSessionFactory());
	      java.util.ArrayList<com.sa.litetwo.srv.card.entity.GG_EDU> tempList = service.selectTempByCARD(tempET);
	      java.util.ArrayList<com.sa.litetwo.srv.card.entity.GG_EDU> oriList = service.selectByCARD(oriET);
	      
	       //放入Map中
	      java.util.HashMap<Object,com.sa.litetwo.srv.card.entity.GG_EDU> oriMap = new java.util.HashMap<Object,com.sa.litetwo.srv.card.entity.GG_EDU>();
	      for(com.sa.litetwo.srv.card.entity.GG_EDU entity:oriList)
	      {
	    	  oriMap.put(entity.getGG_EDUId(),entity);
	      }
	       for(com.sa.litetwo.srv.card.entity.GG_EDU entity:tempList)
	       {
	    	    Object oriKey = entity.get(ORIGINKEY);
	    	    oriMap.remove(oriKey);
	       }
	       
	       //移除删除的
	       for(com.sa.litetwo.srv.card.entity.GG_EDU entity: oriMap.values() )
	       {
	    	   service.remove(entity); 
	       }
	       
	       return tempList;
	 }
	 
	 protected void updateRelatedDataTempMajor_updateGG_EDU(GG_CARD tempET,GG_CARD oriET,java.util.ArrayList<com.sa.litetwo.srv.card.entity.GG_EDU> updateList) throws Exception 
	 {
		 if(updateList==null)
			 return;
	      com.sa.litetwo.srv.card.service.GG_EDUService service = ( com.sa.litetwo.srv.card.service.GG_EDUService)ServiceGlobal.getService(com.sa.litetwo.srv.card.service.GG_EDUService.class,this.getSessionFactory());
	       //建立
	       for(com.sa.litetwo.srv.card.entity.GG_EDU entity:updateList)
	       {
	    	   service.updateTempMajor(entity); 
	       }
	 }

	 protected java.util.ArrayList<com.sa.litetwo.srv.card.entity.GG_GRDHONOR> updateRelatedDataTempMajor_removeGG_GRDHONOR(GG_CARD tempET,GG_CARD oriET) throws Exception 
	 {
	      com.sa.litetwo.srv.card.service.GG_GRDHONORService service = ( com.sa.litetwo.srv.card.service.GG_GRDHONORService)ServiceGlobal.getService(com.sa.litetwo.srv.card.service.GG_GRDHONORService.class,this.getSessionFactory());
	      java.util.ArrayList<com.sa.litetwo.srv.card.entity.GG_GRDHONOR> tempList = service.selectTempByCARD(tempET);
	      java.util.ArrayList<com.sa.litetwo.srv.card.entity.GG_GRDHONOR> oriList = service.selectByCARD(oriET);
	      
	       //放入Map中
	      java.util.HashMap<Object,com.sa.litetwo.srv.card.entity.GG_GRDHONOR> oriMap = new java.util.HashMap<Object,com.sa.litetwo.srv.card.entity.GG_GRDHONOR>();
	      for(com.sa.litetwo.srv.card.entity.GG_GRDHONOR entity:oriList)
	      {
	    	  oriMap.put(entity.getGG_GRDHONORId(),entity);
	      }
	       for(com.sa.litetwo.srv.card.entity.GG_GRDHONOR entity:tempList)
	       {
	    	    Object oriKey = entity.get(ORIGINKEY);
	    	    oriMap.remove(oriKey);
	       }
	       
	       //移除删除的
	       for(com.sa.litetwo.srv.card.entity.GG_GRDHONOR entity: oriMap.values() )
	       {
	    	   service.remove(entity); 
	       }
	       
	       return tempList;
	 }
	 
	 protected void updateRelatedDataTempMajor_updateGG_GRDHONOR(GG_CARD tempET,GG_CARD oriET,java.util.ArrayList<com.sa.litetwo.srv.card.entity.GG_GRDHONOR> updateList) throws Exception 
	 {
		 if(updateList==null)
			 return;
	      com.sa.litetwo.srv.card.service.GG_GRDHONORService service = ( com.sa.litetwo.srv.card.service.GG_GRDHONORService)ServiceGlobal.getService(com.sa.litetwo.srv.card.service.GG_GRDHONORService.class,this.getSessionFactory());
	       //建立
	       for(com.sa.litetwo.srv.card.entity.GG_GRDHONOR entity:updateList)
	       {
	    	   service.updateTempMajor(entity); 
	       }
	 }

	 protected java.util.ArrayList<com.sa.litetwo.srv.card.entity.GG_CERTIF> updateRelatedDataTempMajor_removeGG_CERTIF(GG_CARD tempET,GG_CARD oriET) throws Exception 
	 {
	      com.sa.litetwo.srv.card.service.GG_CERTIFService service = ( com.sa.litetwo.srv.card.service.GG_CERTIFService)ServiceGlobal.getService(com.sa.litetwo.srv.card.service.GG_CERTIFService.class,this.getSessionFactory());
	      java.util.ArrayList<com.sa.litetwo.srv.card.entity.GG_CERTIF> tempList = service.selectTempByCARD(tempET);
	      java.util.ArrayList<com.sa.litetwo.srv.card.entity.GG_CERTIF> oriList = service.selectByCARD(oriET);
	      
	       //放入Map中
	      java.util.HashMap<Object,com.sa.litetwo.srv.card.entity.GG_CERTIF> oriMap = new java.util.HashMap<Object,com.sa.litetwo.srv.card.entity.GG_CERTIF>();
	      for(com.sa.litetwo.srv.card.entity.GG_CERTIF entity:oriList)
	      {
	    	  oriMap.put(entity.getGG_CERTIFId(),entity);
	      }
	       for(com.sa.litetwo.srv.card.entity.GG_CERTIF entity:tempList)
	       {
	    	    Object oriKey = entity.get(ORIGINKEY);
	    	    oriMap.remove(oriKey);
	       }
	       
	       //移除删除的
	       for(com.sa.litetwo.srv.card.entity.GG_CERTIF entity: oriMap.values() )
	       {
	    	   service.remove(entity); 
	       }
	       
	       return tempList;
	 }
	 
	 protected void updateRelatedDataTempMajor_updateGG_CERTIF(GG_CARD tempET,GG_CARD oriET,java.util.ArrayList<com.sa.litetwo.srv.card.entity.GG_CERTIF> updateList) throws Exception 
	 {
		 if(updateList==null)
			 return;
	      com.sa.litetwo.srv.card.service.GG_CERTIFService service = ( com.sa.litetwo.srv.card.service.GG_CERTIFService)ServiceGlobal.getService(com.sa.litetwo.srv.card.service.GG_CERTIFService.class,this.getSessionFactory());
	       //建立
	       for(com.sa.litetwo.srv.card.entity.GG_CERTIF entity:updateList)
	       {
	    	   service.updateTempMajor(entity); 
	       }
	 }

	 protected java.util.ArrayList<com.sa.litetwo.srv.card.entity.GG_GRDPOST> updateRelatedDataTempMajor_removeGG_GRDPOST(GG_CARD tempET,GG_CARD oriET) throws Exception 
	 {
	      com.sa.litetwo.srv.card.service.GG_GRDPOSTService service = ( com.sa.litetwo.srv.card.service.GG_GRDPOSTService)ServiceGlobal.getService(com.sa.litetwo.srv.card.service.GG_GRDPOSTService.class,this.getSessionFactory());
	      java.util.ArrayList<com.sa.litetwo.srv.card.entity.GG_GRDPOST> tempList = service.selectTempByCARD(tempET);
	      java.util.ArrayList<com.sa.litetwo.srv.card.entity.GG_GRDPOST> oriList = service.selectByCARD(oriET);
	      
	       //放入Map中
	      java.util.HashMap<Object,com.sa.litetwo.srv.card.entity.GG_GRDPOST> oriMap = new java.util.HashMap<Object,com.sa.litetwo.srv.card.entity.GG_GRDPOST>();
	      for(com.sa.litetwo.srv.card.entity.GG_GRDPOST entity:oriList)
	      {
	    	  oriMap.put(entity.getGG_GRDPOSTId(),entity);
	      }
	       for(com.sa.litetwo.srv.card.entity.GG_GRDPOST entity:tempList)
	       {
	    	    Object oriKey = entity.get(ORIGINKEY);
	    	    oriMap.remove(oriKey);
	       }
	       
	       //移除删除的
	       for(com.sa.litetwo.srv.card.entity.GG_GRDPOST entity: oriMap.values() )
	       {
	    	   service.remove(entity); 
	       }
	       
	       return tempList;
	 }
	 
	 protected void updateRelatedDataTempMajor_updateGG_GRDPOST(GG_CARD tempET,GG_CARD oriET,java.util.ArrayList<com.sa.litetwo.srv.card.entity.GG_GRDPOST> updateList) throws Exception 
	 {
		 if(updateList==null)
			 return;
	      com.sa.litetwo.srv.card.service.GG_GRDPOSTService service = ( com.sa.litetwo.srv.card.service.GG_GRDPOSTService)ServiceGlobal.getService(com.sa.litetwo.srv.card.service.GG_GRDPOSTService.class,this.getSessionFactory());
	       //建立
	       for(com.sa.litetwo.srv.card.entity.GG_GRDPOST entity:updateList)
	       {
	    	   service.updateTempMajor(entity); 
	       }
	 }

	 protected java.util.ArrayList<com.sa.litetwo.srv.card.entity.GG_SKILL> updateRelatedDataTempMajor_removeGG_SKILL(GG_CARD tempET,GG_CARD oriET) throws Exception 
	 {
	      com.sa.litetwo.srv.card.service.GG_SKILLService service = ( com.sa.litetwo.srv.card.service.GG_SKILLService)ServiceGlobal.getService(com.sa.litetwo.srv.card.service.GG_SKILLService.class,this.getSessionFactory());
	      java.util.ArrayList<com.sa.litetwo.srv.card.entity.GG_SKILL> tempList = service.selectTempByCARD(tempET);
	      java.util.ArrayList<com.sa.litetwo.srv.card.entity.GG_SKILL> oriList = service.selectByCARD(oriET);
	      
	       //放入Map中
	      java.util.HashMap<Object,com.sa.litetwo.srv.card.entity.GG_SKILL> oriMap = new java.util.HashMap<Object,com.sa.litetwo.srv.card.entity.GG_SKILL>();
	      for(com.sa.litetwo.srv.card.entity.GG_SKILL entity:oriList)
	      {
	    	  oriMap.put(entity.getGG_SKILLId(),entity);
	      }
	       for(com.sa.litetwo.srv.card.entity.GG_SKILL entity:tempList)
	       {
	    	    Object oriKey = entity.get(ORIGINKEY);
	    	    oriMap.remove(oriKey);
	       }
	       
	       //移除删除的
	       for(com.sa.litetwo.srv.card.entity.GG_SKILL entity: oriMap.values() )
	       {
	    	   service.remove(entity); 
	       }
	       
	       return tempList;
	 }
	 
	 protected void updateRelatedDataTempMajor_updateGG_SKILL(GG_CARD tempET,GG_CARD oriET,java.util.ArrayList<com.sa.litetwo.srv.card.entity.GG_SKILL> updateList) throws Exception 
	 {
		 if(updateList==null)
			 return;
	      com.sa.litetwo.srv.card.service.GG_SKILLService service = ( com.sa.litetwo.srv.card.service.GG_SKILLService)ServiceGlobal.getService(com.sa.litetwo.srv.card.service.GG_SKILLService.class,this.getSessionFactory());
	       //建立
	       for(com.sa.litetwo.srv.card.entity.GG_SKILL entity:updateList)
	       {
	    	   service.updateTempMajor(entity); 
	       }
	 }

	 protected java.util.ArrayList<com.sa.litetwo.srv.card.entity.GG_ATTACH> updateRelatedDataTempMajor_removeGG_ATTACH(GG_CARD tempET,GG_CARD oriET) throws Exception 
	 {
	      com.sa.litetwo.srv.card.service.GG_ATTACHService service = ( com.sa.litetwo.srv.card.service.GG_ATTACHService)ServiceGlobal.getService(com.sa.litetwo.srv.card.service.GG_ATTACHService.class,this.getSessionFactory());
	      java.util.ArrayList<com.sa.litetwo.srv.card.entity.GG_ATTACH> tempList = service.selectTempByCARD(tempET);
	      java.util.ArrayList<com.sa.litetwo.srv.card.entity.GG_ATTACH> oriList = service.selectByCARD(oriET);
	      
	       //放入Map中
	      java.util.HashMap<Object,com.sa.litetwo.srv.card.entity.GG_ATTACH> oriMap = new java.util.HashMap<Object,com.sa.litetwo.srv.card.entity.GG_ATTACH>();
	      for(com.sa.litetwo.srv.card.entity.GG_ATTACH entity:oriList)
	      {
	    	  oriMap.put(entity.getGG_ATTACHId(),entity);
	      }
	       for(com.sa.litetwo.srv.card.entity.GG_ATTACH entity:tempList)
	       {
	    	    Object oriKey = entity.get(ORIGINKEY);
	    	    oriMap.remove(oriKey);
	       }
	       
	       //移除删除的
	       for(com.sa.litetwo.srv.card.entity.GG_ATTACH entity: oriMap.values() )
	       {
	    	   service.remove(entity); 
	       }
	       
	       return tempList;
	 }
	 
	 protected void updateRelatedDataTempMajor_updateGG_ATTACH(GG_CARD tempET,GG_CARD oriET,java.util.ArrayList<com.sa.litetwo.srv.card.entity.GG_ATTACH> updateList) throws Exception 
	 {
		 if(updateList==null)
			 return;
	      com.sa.litetwo.srv.card.service.GG_ATTACHService service = ( com.sa.litetwo.srv.card.service.GG_ATTACHService)ServiceGlobal.getService(com.sa.litetwo.srv.card.service.GG_ATTACHService.class,this.getSessionFactory());
	       //建立
	       for(com.sa.litetwo.srv.card.entity.GG_ATTACH entity:updateList)
	       {
	    	   service.updateTempMajor(entity); 
	       }
	 }

	 protected java.util.ArrayList<com.sa.litetwo.srv.card.entity.GG_TRAIN> updateRelatedDataTempMajor_removeGG_TRAIN(GG_CARD tempET,GG_CARD oriET) throws Exception 
	 {
	      com.sa.litetwo.srv.card.service.GG_TRAINService service = ( com.sa.litetwo.srv.card.service.GG_TRAINService)ServiceGlobal.getService(com.sa.litetwo.srv.card.service.GG_TRAINService.class,this.getSessionFactory());
	      java.util.ArrayList<com.sa.litetwo.srv.card.entity.GG_TRAIN> tempList = service.selectTempByCARD(tempET);
	      java.util.ArrayList<com.sa.litetwo.srv.card.entity.GG_TRAIN> oriList = service.selectByCARD(oriET);
	      
	       //放入Map中
	      java.util.HashMap<Object,com.sa.litetwo.srv.card.entity.GG_TRAIN> oriMap = new java.util.HashMap<Object,com.sa.litetwo.srv.card.entity.GG_TRAIN>();
	      for(com.sa.litetwo.srv.card.entity.GG_TRAIN entity:oriList)
	      {
	    	  oriMap.put(entity.getGG_TRAINId(),entity);
	      }
	       for(com.sa.litetwo.srv.card.entity.GG_TRAIN entity:tempList)
	       {
	    	    Object oriKey = entity.get(ORIGINKEY);
	    	    oriMap.remove(oriKey);
	       }
	       
	       //移除删除的
	       for(com.sa.litetwo.srv.card.entity.GG_TRAIN entity: oriMap.values() )
	       {
	    	   service.remove(entity); 
	       }
	       
	       return tempList;
	 }
	 
	 protected void updateRelatedDataTempMajor_updateGG_TRAIN(GG_CARD tempET,GG_CARD oriET,java.util.ArrayList<com.sa.litetwo.srv.card.entity.GG_TRAIN> updateList) throws Exception 
	 {
		 if(updateList==null)
			 return;
	      com.sa.litetwo.srv.card.service.GG_TRAINService service = ( com.sa.litetwo.srv.card.service.GG_TRAINService)ServiceGlobal.getService(com.sa.litetwo.srv.card.service.GG_TRAINService.class,this.getSessionFactory());
	       //建立
	       for(com.sa.litetwo.srv.card.entity.GG_TRAIN entity:updateList)
	       {
	    	   service.updateTempMajor(entity); 
	       }
	 }

	 protected java.util.ArrayList<com.sa.litetwo.srv.card.entity.GG_WORK> updateRelatedDataTempMajor_removeGG_WORK(GG_CARD tempET,GG_CARD oriET) throws Exception 
	 {
	      com.sa.litetwo.srv.card.service.GG_WORKService service = ( com.sa.litetwo.srv.card.service.GG_WORKService)ServiceGlobal.getService(com.sa.litetwo.srv.card.service.GG_WORKService.class,this.getSessionFactory());
	      java.util.ArrayList<com.sa.litetwo.srv.card.entity.GG_WORK> tempList = service.selectTempByCARD(tempET);
	      java.util.ArrayList<com.sa.litetwo.srv.card.entity.GG_WORK> oriList = service.selectByCARD(oriET);
	      
	       //放入Map中
	      java.util.HashMap<Object,com.sa.litetwo.srv.card.entity.GG_WORK> oriMap = new java.util.HashMap<Object,com.sa.litetwo.srv.card.entity.GG_WORK>();
	      for(com.sa.litetwo.srv.card.entity.GG_WORK entity:oriList)
	      {
	    	  oriMap.put(entity.getGG_WORKId(),entity);
	      }
	       for(com.sa.litetwo.srv.card.entity.GG_WORK entity:tempList)
	       {
	    	    Object oriKey = entity.get(ORIGINKEY);
	    	    oriMap.remove(oriKey);
	       }
	       
	       //移除删除的
	       for(com.sa.litetwo.srv.card.entity.GG_WORK entity: oriMap.values() )
	       {
	    	   service.remove(entity); 
	       }
	       
	       return tempList;
	 }
	 
	 protected void updateRelatedDataTempMajor_updateGG_WORK(GG_CARD tempET,GG_CARD oriET,java.util.ArrayList<com.sa.litetwo.srv.card.entity.GG_WORK> updateList) throws Exception 
	 {
		 if(updateList==null)
			 return;
	      com.sa.litetwo.srv.card.service.GG_WORKService service = ( com.sa.litetwo.srv.card.service.GG_WORKService)ServiceGlobal.getService(com.sa.litetwo.srv.card.service.GG_WORKService.class,this.getSessionFactory());
	       //建立
	       for(com.sa.litetwo.srv.card.entity.GG_WORK entity:updateList)
	       {
	    	   service.updateTempMajor(entity); 
	       }
	 }

	 protected java.util.ArrayList<com.sa.litetwo.srv.card.entity.GG_PROJ> updateRelatedDataTempMajor_removeGG_PROJ(GG_CARD tempET,GG_CARD oriET) throws Exception 
	 {
	      com.sa.litetwo.srv.card.service.GG_PROJService service = ( com.sa.litetwo.srv.card.service.GG_PROJService)ServiceGlobal.getService(com.sa.litetwo.srv.card.service.GG_PROJService.class,this.getSessionFactory());
	      java.util.ArrayList<com.sa.litetwo.srv.card.entity.GG_PROJ> tempList = service.selectTempByCARD(tempET);
	      java.util.ArrayList<com.sa.litetwo.srv.card.entity.GG_PROJ> oriList = service.selectByCARD(oriET);
	      
	       //放入Map中
	      java.util.HashMap<Object,com.sa.litetwo.srv.card.entity.GG_PROJ> oriMap = new java.util.HashMap<Object,com.sa.litetwo.srv.card.entity.GG_PROJ>();
	      for(com.sa.litetwo.srv.card.entity.GG_PROJ entity:oriList)
	      {
	    	  oriMap.put(entity.getGG_PROJId(),entity);
	      }
	       for(com.sa.litetwo.srv.card.entity.GG_PROJ entity:tempList)
	       {
	    	    Object oriKey = entity.get(ORIGINKEY);
	    	    oriMap.remove(oriKey);
	       }
	       
	       //移除删除的
	       for(com.sa.litetwo.srv.card.entity.GG_PROJ entity: oriMap.values() )
	       {
	    	   service.remove(entity); 
	       }
	       
	       return tempList;
	 }
	 
	 protected void updateRelatedDataTempMajor_updateGG_PROJ(GG_CARD tempET,GG_CARD oriET,java.util.ArrayList<com.sa.litetwo.srv.card.entity.GG_PROJ> updateList) throws Exception 
	 {
		 if(updateList==null)
			 return;
	      com.sa.litetwo.srv.card.service.GG_PROJService service = ( com.sa.litetwo.srv.card.service.GG_PROJService)ServiceGlobal.getService(com.sa.litetwo.srv.card.service.GG_PROJService.class,this.getSessionFactory());
	       //建立
	       for(com.sa.litetwo.srv.card.entity.GG_PROJ entity:updateList)
	       {
	    	   service.updateTempMajor(entity); 
	       }
	 }

	 protected java.util.ArrayList<com.sa.litetwo.srv.card.entity.GG_OTHER> updateRelatedDataTempMajor_removeGG_OTHER(GG_CARD tempET,GG_CARD oriET) throws Exception 
	 {
	      com.sa.litetwo.srv.card.service.GG_OTHERService service = ( com.sa.litetwo.srv.card.service.GG_OTHERService)ServiceGlobal.getService(com.sa.litetwo.srv.card.service.GG_OTHERService.class,this.getSessionFactory());
	      java.util.ArrayList<com.sa.litetwo.srv.card.entity.GG_OTHER> tempList = service.selectTempByCARD(tempET);
	      java.util.ArrayList<com.sa.litetwo.srv.card.entity.GG_OTHER> oriList = service.selectByCARD(oriET);
	      
	       //放入Map中
	      java.util.HashMap<Object,com.sa.litetwo.srv.card.entity.GG_OTHER> oriMap = new java.util.HashMap<Object,com.sa.litetwo.srv.card.entity.GG_OTHER>();
	      for(com.sa.litetwo.srv.card.entity.GG_OTHER entity:oriList)
	      {
	    	  oriMap.put(entity.getGG_OTHERId(),entity);
	      }
	       for(com.sa.litetwo.srv.card.entity.GG_OTHER entity:tempList)
	       {
	    	    Object oriKey = entity.get(ORIGINKEY);
	    	    oriMap.remove(oriKey);
	       }
	       
	       //移除删除的
	       for(com.sa.litetwo.srv.card.entity.GG_OTHER entity: oriMap.values() )
	       {
	    	   service.remove(entity); 
	       }
	       
	       return tempList;
	 }
	 
	 protected void updateRelatedDataTempMajor_updateGG_OTHER(GG_CARD tempET,GG_CARD oriET,java.util.ArrayList<com.sa.litetwo.srv.card.entity.GG_OTHER> updateList) throws Exception 
	 {
		 if(updateList==null)
			 return;
	      com.sa.litetwo.srv.card.service.GG_OTHERService service = ( com.sa.litetwo.srv.card.service.GG_OTHERService)ServiceGlobal.getService(com.sa.litetwo.srv.card.service.GG_OTHERService.class,this.getSessionFactory());
	       //建立
	       for(com.sa.litetwo.srv.card.entity.GG_OTHER entity:updateList)
	       {
	    	   service.updateTempMajor(entity); 
	       }
	 }

	/* (non-Javadoc)
	 * @see net.ibizsys.paas.service.ServiceBase#onRemoveEntityUncopyValues(net.ibizsys.paas.entity.IEntity, boolean)
	 */
	@Override
	protected void onRemoveEntityUncopyValues(GG_CARD et, boolean bTempMode) throws Exception
	{
		super.onRemoveEntityUncopyValues(et,  bTempMode);
        et.resetGG_CARDName();
	}

	
    /* (non-Javadoc)
     * @see net.ibizsys.paas.service.ServiceBase#onCheckEntity(boolean, net.ibizsys.paas.entity.IEntity, boolean, boolean, net.ibizsys.paas.entity.EntityError)
     */
	@Override
	protected void onCheckEntity(boolean bBaseMode,GG_CARD  et, boolean bCreate, boolean bTempMode,EntityError entityError) throws Exception
	{
		EntityFieldError entityFieldError = null;
          //检查属性 信息卡标识
          entityFieldError = onCheckField_GG_CARDId( bBaseMode,  et,  bCreate,  bTempMode);
          if(entityFieldError!=null){entityError.register(entityFieldError);}
          //检查属性 名称
          entityFieldError = onCheckField_GG_CARDName( bBaseMode,  et,  bCreate,  bTempMode);
          if(entityFieldError!=null){entityError.register(entityFieldError);}
          //检查属性 公司/单位
          entityFieldError = onCheckField_GG_WORKName( bBaseMode,  et,  bCreate,  bTempMode);
          if(entityFieldError!=null){entityError.register(entityFieldError);}
          //检查属性 姓名
          entityFieldError = onCheckField_XM( bBaseMode,  et,  bCreate,  bTempMode);
          if(entityFieldError!=null){entityError.register(entityFieldError);}
          //检查属性 性别
          entityFieldError = onCheckField_XB( bBaseMode,  et,  bCreate,  bTempMode);
          if(entityFieldError!=null){entityError.register(entityFieldError);}
          //检查属性 出生日期
          entityFieldError = onCheckField_CSRQ( bBaseMode,  et,  bCreate,  bTempMode);
          if(entityFieldError!=null){entityError.register(entityFieldError);}
          //检查属性 开始工作年份
          entityFieldError = onCheckField_KSGZNF( bBaseMode,  et,  bCreate,  bTempMode);
          if(entityFieldError!=null){entityError.register(entityFieldError);}
          //检查属性 手机
          entityFieldError = onCheckField_SJ( bBaseMode,  et,  bCreate,  bTempMode);
          if(entityFieldError!=null){entityError.register(entityFieldError);}
          //检查属性 求职状态
          entityFieldError = onCheckField_QZZT( bBaseMode,  et,  bCreate,  bTempMode);
          if(entityFieldError!=null){entityError.register(entityFieldError);}
          //检查属性 邮箱
          entityFieldError = onCheckField_YX( bBaseMode,  et,  bCreate,  bTempMode);
          if(entityFieldError!=null){entityError.register(entityFieldError);}
          //检查属性 社交账号
          entityFieldError = onCheckField_SJZH( bBaseMode,  et,  bCreate,  bTempMode);
          if(entityFieldError!=null){entityError.register(entityFieldError);}
          //检查属性 居住地区
          entityFieldError = onCheckField_ZD( bBaseMode,  et,  bCreate,  bTempMode);
          if(entityFieldError!=null){entityError.register(entityFieldError);}
          //检查属性 籍贯
          entityFieldError = onCheckField_HKGJ( bBaseMode,  et,  bCreate,  bTempMode);
          if(entityFieldError!=null){entityError.register(entityFieldError);}
          //检查属性 婚姻状态
          entityFieldError = onCheckField_HYZT( bBaseMode,  et,  bCreate,  bTempMode);
          if(entityFieldError!=null){entityError.register(entityFieldError);}
          //检查属性 证件号
          entityFieldError = onCheckField_ZJH( bBaseMode,  et,  bCreate,  bTempMode);
          if(entityFieldError!=null){entityError.register(entityFieldError);}
          //检查属性 政治面貌
          entityFieldError = onCheckField_ZZMM( bBaseMode,  et,  bCreate,  bTempMode);
          if(entityFieldError!=null){entityError.register(entityFieldError);}
          //检查属性 其他联系方式
          entityFieldError = onCheckField_QTLXFS( bBaseMode,  et,  bCreate,  bTempMode);
          if(entityFieldError!=null){entityError.register(entityFieldError);}
          //检查属性 身高
          entityFieldError = onCheckField_SG( bBaseMode,  et,  bCreate,  bTempMode);
          if(entityFieldError!=null){entityError.register(entityFieldError);}
          //检查属性 家庭住址
          entityFieldError = onCheckField_JTZZ( bBaseMode,  et,  bCreate,  bTempMode);
          if(entityFieldError!=null){entityError.register(entityFieldError);}
          //检查属性 个人主页
          entityFieldError = onCheckField_GRZY( bBaseMode,  et,  bCreate,  bTempMode);
          if(entityFieldError!=null){entityError.register(entityFieldError);}
          //检查属性 目前年收入
          entityFieldError = onCheckField_MQNSR( bBaseMode,  et,  bCreate,  bTempMode);
          if(entityFieldError!=null){entityError.register(entityFieldError);}
          //检查属性 基本工资
          entityFieldError = onCheckField_JBGZ( bBaseMode,  et,  bCreate,  bTempMode);
          if(entityFieldError!=null){entityError.register(entityFieldError);}
          //检查属性 补贴津贴
          entityFieldError = onCheckField_BTJT( bBaseMode,  et,  bCreate,  bTempMode);
          if(entityFieldError!=null){entityError.register(entityFieldError);}
          //检查属性 奖金佣金
          entityFieldError = onCheckField_JJYJ( bBaseMode,  et,  bCreate,  bTempMode);
          if(entityFieldError!=null){entityError.register(entityFieldError);}
          //检查属性 股权收益
          entityFieldError = onCheckField_GQSY( bBaseMode,  et,  bCreate,  bTempMode);
          if(entityFieldError!=null){entityError.register(entityFieldError);}
          //检查属性 期望月薪
          entityFieldError = onCheckField_QWNX( bBaseMode,  et,  bCreate,  bTempMode);
          if(entityFieldError!=null){entityError.register(entityFieldError);}
          //检查属性 地点
          entityFieldError = onCheckField_DD( bBaseMode,  et,  bCreate,  bTempMode);
          if(entityFieldError!=null){entityError.register(entityFieldError);}
          //检查属性 行业
          entityFieldError = onCheckField_HY( bBaseMode,  et,  bCreate,  bTempMode);
          if(entityFieldError!=null){entityError.register(entityFieldError);}
          //检查属性 第一学历
          entityFieldError = onCheckField_ZGXL( bBaseMode,  et,  bCreate,  bTempMode);
          if(entityFieldError!=null){entityError.register(entityFieldError);}
          //检查属性 职能类别
          entityFieldError = onCheckField_ZN( bBaseMode,  et,  bCreate,  bTempMode);
          if(entityFieldError!=null){entityError.register(entityFieldError);}
          //检查属性 职能-房地产
          entityFieldError = onCheckField_Zn_fdc( bBaseMode,  et,  bCreate,  bTempMode);
          if(entityFieldError!=null){entityError.register(entityFieldError);}
          //检查属性 职能-互联网
          entityFieldError = onCheckField_Zn_hlw( bBaseMode,  et,  bCreate,  bTempMode);
          if(entityFieldError!=null){entityError.register(entityFieldError);}
          //检查属性 职能-金融银行
          entityFieldError = onCheckField_Zn_jryh( bBaseMode,  et,  bCreate,  bTempMode);
          if(entityFieldError!=null){entityError.register(entityFieldError);}
          //检查属性 职能-机械制造
          entityFieldError = onCheckField_Zn_jxzz( bBaseMode,  et,  bCreate,  bTempMode);
          if(entityFieldError!=null){entityError.register(entityFieldError);}
          //检查属性 职能-生物医药
          entityFieldError = onCheckField_Zn_swyy( bBaseMode,  et,  bCreate,  bTempMode);
          if(entityFieldError!=null){entityError.register(entityFieldError);}
          //检查属性 职能-商业零售
          entityFieldError = onCheckField_Zn_syls( bBaseMode,  et,  bCreate,  bTempMode);
          if(entityFieldError!=null){entityError.register(entityFieldError);}
          //检查属性 个人标签
          entityFieldError = onCheckField_GRBQ( bBaseMode,  et,  bCreate,  bTempMode);
          if(entityFieldError!=null){entityError.register(entityFieldError);}
          //检查属性 自我评价
          entityFieldError = onCheckField_ZWPJ( bBaseMode,  et,  bCreate,  bTempMode);
          if(entityFieldError!=null){entityError.register(entityFieldError);}
          //检查属性 到岗时间
          entityFieldError = onCheckField_DGSJ( bBaseMode,  et,  bCreate,  bTempMode);
          if(entityFieldError!=null){entityError.register(entityFieldError);}
          //检查属性 工作类型
          entityFieldError = onCheckField_GZLX( bBaseMode,  et,  bCreate,  bTempMode);
          if(entityFieldError!=null){entityError.register(entityFieldError);}
          //检查属性 已推荐企业
          entityFieldError = onCheckField_YTJQY( bBaseMode,  et,  bCreate,  bTempMode);
          if(entityFieldError!=null){entityError.register(entityFieldError);}
          //检查属性 推荐岗位所在城市
          entityFieldError = onCheckField_TJGWSZCS( bBaseMode,  et,  bCreate,  bTempMode);
          if(entityFieldError!=null){entityError.register(entityFieldError);}
          //检查属性 推荐时间
          entityFieldError = onCheckField_TJSJ( bBaseMode,  et,  bCreate,  bTempMode);
          if(entityFieldError!=null){entityError.register(entityFieldError);}
          //检查属性 照片
          entityFieldError = onCheckField_ZP( bBaseMode,  et,  bCreate,  bTempMode);
          if(entityFieldError!=null){entityError.register(entityFieldError);}
		super.onCheckEntity(bBaseMode,et,  bCreate,bTempMode,entityError);
	}
	
	
	/**
	 * 获取属性[GG_CARDId]值错误
	 * @param bBaseMode 是否为基本检查模式，基本检查模式执行值类型，长度及属性值规则检查，非基本模式进行重复值检查
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据
	 * @param bTempMode 是否为临时数据模式
	 * @throws Exception
	 */
	protected EntityFieldError onCheckField_GG_CARDId(boolean bBaseMode,GG_CARD et, boolean bCreate, boolean bTempMode) throws Exception
	{
		//判断是否有值	
		if(!et.isGG_CARDIdDirty())
			return null;
		
		String value = et.getGG_CARDId();
		if(bBaseMode)
		{
			if(bCreate)
			{
		        if(StringHelper.isNullOrEmpty(value))
		        {
		        	EntityFieldError entityFieldError = new EntityFieldError();
		        	entityFieldError.setFieldName(GG_CARD.FIELD_GG_CARDID);
		        	entityFieldError.setErrorType(EntityFieldError.ERROR_EMPTY);
		        	return entityFieldError;
		        }
			}
			
			String strRuleInfo  = null;
			//检查值规则[默认规则]
			strRuleInfo =onTestValueRule_GG_CARDId_Default( et,  bCreate,  bTempMode);
			if(!StringHelper.isNullOrEmpty(strRuleInfo))
            {
           	 		EntityFieldError entityFieldError = new EntityFieldError();
           	 		entityFieldError.setFieldName(GG_CARD.FIELD_GG_CARDID);
           	 		entityFieldError.setErrorType(EntityFieldError.ERROR_VALUERULE);
		         	entityFieldError.setErrorInfo(strRuleInfo);
		         	return entityFieldError;
            }
		}
		else
		{
		}
		return null;
	}
	

	/**
	 * 获取属性[GG_CARDName]值错误
	 * @param bBaseMode 是否为基本检查模式，基本检查模式执行值类型，长度及属性值规则检查，非基本模式进行重复值检查
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据
	 * @param bTempMode 是否为临时数据模式
	 * @throws Exception
	 */
	protected EntityFieldError onCheckField_GG_CARDName(boolean bBaseMode,GG_CARD et, boolean bCreate, boolean bTempMode) throws Exception
	{
		//判断是否有值	
		if(!et.isGG_CARDNameDirty())
			return null;
		
		String value = et.getGG_CARDName();
		if(bBaseMode)
		{
			if(bCreate)
			{
			}
			
			String strRuleInfo  = null;
			//检查值规则[默认规则]
			strRuleInfo =onTestValueRule_GG_CARDName_Default( et,  bCreate,  bTempMode);
			if(!StringHelper.isNullOrEmpty(strRuleInfo))
            {
           	 		EntityFieldError entityFieldError = new EntityFieldError();
           	 		entityFieldError.setFieldName(GG_CARD.FIELD_GG_CARDNAME);
           	 		entityFieldError.setErrorType(EntityFieldError.ERROR_VALUERULE);
		         	entityFieldError.setErrorInfo(strRuleInfo);
		         	return entityFieldError;
            }
		}
		else
		{
		}
		return null;
	}
	

	/**
	 * 获取属性[GG_WORKName]值错误
	 * @param bBaseMode 是否为基本检查模式，基本检查模式执行值类型，长度及属性值规则检查，非基本模式进行重复值检查
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据
	 * @param bTempMode 是否为临时数据模式
	 * @throws Exception
	 */
	protected EntityFieldError onCheckField_GG_WORKName(boolean bBaseMode,GG_CARD et, boolean bCreate, boolean bTempMode) throws Exception
	{
		//判断是否有值	
		if(!et.isGG_WORKNameDirty())
			return null;
		
		String value = et.getGG_WORKName();
		if(bBaseMode)
		{
			if(bCreate)
			{
			}
			
			String strRuleInfo  = null;
			//检查值规则[默认规则]
			strRuleInfo =onTestValueRule_GG_WORKName_Default( et,  bCreate,  bTempMode);
			if(!StringHelper.isNullOrEmpty(strRuleInfo))
            {
           	 		EntityFieldError entityFieldError = new EntityFieldError();
           	 		entityFieldError.setFieldName(GG_CARD.FIELD_GG_WORKNAME);
           	 		entityFieldError.setErrorType(EntityFieldError.ERROR_VALUERULE);
		         	entityFieldError.setErrorInfo(strRuleInfo);
		         	return entityFieldError;
            }
		}
		else
		{
		}
		return null;
	}
	

	/**
	 * 获取属性[XM]值错误
	 * @param bBaseMode 是否为基本检查模式，基本检查模式执行值类型，长度及属性值规则检查，非基本模式进行重复值检查
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据
	 * @param bTempMode 是否为临时数据模式
	 * @throws Exception
	 */
	protected EntityFieldError onCheckField_XM(boolean bBaseMode,GG_CARD et, boolean bCreate, boolean bTempMode) throws Exception
	{
		//判断是否有值	
		if(!et.isXMDirty())
			return null;
		
		String value = et.getXM();
		if(bBaseMode)
		{
			if(bCreate)
			{
			}
			
			String strRuleInfo  = null;
			//检查值规则[默认规则]
			strRuleInfo =onTestValueRule_XM_Default( et,  bCreate,  bTempMode);
			if(!StringHelper.isNullOrEmpty(strRuleInfo))
            {
           	 		EntityFieldError entityFieldError = new EntityFieldError();
           	 		entityFieldError.setFieldName(GG_CARD.FIELD_XM);
           	 		entityFieldError.setErrorType(EntityFieldError.ERROR_VALUERULE);
		         	entityFieldError.setErrorInfo(strRuleInfo);
		         	return entityFieldError;
            }
		}
		else
		{
		}
		return null;
	}
	

	/**
	 * 获取属性[XB]值错误
	 * @param bBaseMode 是否为基本检查模式，基本检查模式执行值类型，长度及属性值规则检查，非基本模式进行重复值检查
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据
	 * @param bTempMode 是否为临时数据模式
	 * @throws Exception
	 */
	protected EntityFieldError onCheckField_XB(boolean bBaseMode,GG_CARD et, boolean bCreate, boolean bTempMode) throws Exception
	{
		//判断是否有值	
		if(!et.isXBDirty())
			return null;
		
		String value = et.getXB();
		if(bBaseMode)
		{
			if(bCreate)
			{
			}
			
			String strRuleInfo  = null;
			//检查值规则[默认规则]
			strRuleInfo =onTestValueRule_XB_Default( et,  bCreate,  bTempMode);
			if(!StringHelper.isNullOrEmpty(strRuleInfo))
            {
           	 		EntityFieldError entityFieldError = new EntityFieldError();
           	 		entityFieldError.setFieldName(GG_CARD.FIELD_XB);
           	 		entityFieldError.setErrorType(EntityFieldError.ERROR_VALUERULE);
		         	entityFieldError.setErrorInfo(strRuleInfo);
		         	return entityFieldError;
            }
		}
		else
		{
		}
		return null;
	}
	

	/**
	 * 获取属性[CSRQ]值错误
	 * @param bBaseMode 是否为基本检查模式，基本检查模式执行值类型，长度及属性值规则检查，非基本模式进行重复值检查
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据
	 * @param bTempMode 是否为临时数据模式
	 * @throws Exception
	 */
	protected EntityFieldError onCheckField_CSRQ(boolean bBaseMode,GG_CARD et, boolean bCreate, boolean bTempMode) throws Exception
	{
		//判断是否有值	
		if(!et.isCSRQDirty())
			return null;
		
		Timestamp value = et.getCSRQ();
		if(bBaseMode)
		{
			if(bCreate)
			{
			}
			
			String strRuleInfo  = null;
			//检查值规则[默认规则]
			strRuleInfo =onTestValueRule_CSRQ_Default( et,  bCreate,  bTempMode);
			if(!StringHelper.isNullOrEmpty(strRuleInfo))
            {
           	 		EntityFieldError entityFieldError = new EntityFieldError();
           	 		entityFieldError.setFieldName(GG_CARD.FIELD_CSRQ);
           	 		entityFieldError.setErrorType(EntityFieldError.ERROR_VALUERULE);
		         	entityFieldError.setErrorInfo(strRuleInfo);
		         	return entityFieldError;
            }
		}
		else
		{
		}
		return null;
	}
	

	/**
	 * 获取属性[KSGZNF]值错误
	 * @param bBaseMode 是否为基本检查模式，基本检查模式执行值类型，长度及属性值规则检查，非基本模式进行重复值检查
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据
	 * @param bTempMode 是否为临时数据模式
	 * @throws Exception
	 */
	protected EntityFieldError onCheckField_KSGZNF(boolean bBaseMode,GG_CARD et, boolean bCreate, boolean bTempMode) throws Exception
	{
		//判断是否有值	
		if(!et.isKSGZNFDirty())
			return null;
		
		Timestamp value = et.getKSGZNF();
		if(bBaseMode)
		{
			if(bCreate)
			{
			}
			
			String strRuleInfo  = null;
			//检查值规则[默认规则]
			strRuleInfo =onTestValueRule_KSGZNF_Default( et,  bCreate,  bTempMode);
			if(!StringHelper.isNullOrEmpty(strRuleInfo))
            {
           	 		EntityFieldError entityFieldError = new EntityFieldError();
           	 		entityFieldError.setFieldName(GG_CARD.FIELD_KSGZNF);
           	 		entityFieldError.setErrorType(EntityFieldError.ERROR_VALUERULE);
		         	entityFieldError.setErrorInfo(strRuleInfo);
		         	return entityFieldError;
            }
		}
		else
		{
		}
		return null;
	}
	

	/**
	 * 获取属性[SJ]值错误
	 * @param bBaseMode 是否为基本检查模式，基本检查模式执行值类型，长度及属性值规则检查，非基本模式进行重复值检查
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据
	 * @param bTempMode 是否为临时数据模式
	 * @throws Exception
	 */
	protected EntityFieldError onCheckField_SJ(boolean bBaseMode,GG_CARD et, boolean bCreate, boolean bTempMode) throws Exception
	{
		//判断是否有值	
		if(!et.isSJDirty())
			return null;
		
		String value = et.getSJ();
		if(bBaseMode)
		{
			if(bCreate)
			{
			}
			
			String strRuleInfo  = null;
			//检查值规则[默认规则]
			strRuleInfo =onTestValueRule_SJ_Default( et,  bCreate,  bTempMode);
			if(!StringHelper.isNullOrEmpty(strRuleInfo))
            {
           	 		EntityFieldError entityFieldError = new EntityFieldError();
           	 		entityFieldError.setFieldName(GG_CARD.FIELD_SJ);
           	 		entityFieldError.setErrorType(EntityFieldError.ERROR_VALUERULE);
		         	entityFieldError.setErrorInfo(strRuleInfo);
		         	return entityFieldError;
            }
		}
		else
		{
		}
		return null;
	}
	

	/**
	 * 获取属性[QZZT]值错误
	 * @param bBaseMode 是否为基本检查模式，基本检查模式执行值类型，长度及属性值规则检查，非基本模式进行重复值检查
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据
	 * @param bTempMode 是否为临时数据模式
	 * @throws Exception
	 */
	protected EntityFieldError onCheckField_QZZT(boolean bBaseMode,GG_CARD et, boolean bCreate, boolean bTempMode) throws Exception
	{
		//判断是否有值	
		if(!et.isQZZTDirty())
			return null;
		
		String value = et.getQZZT();
		if(bBaseMode)
		{
			if(bCreate)
			{
			}
			
			String strRuleInfo  = null;
			//检查值规则[默认规则]
			strRuleInfo =onTestValueRule_QZZT_Default( et,  bCreate,  bTempMode);
			if(!StringHelper.isNullOrEmpty(strRuleInfo))
            {
           	 		EntityFieldError entityFieldError = new EntityFieldError();
           	 		entityFieldError.setFieldName(GG_CARD.FIELD_QZZT);
           	 		entityFieldError.setErrorType(EntityFieldError.ERROR_VALUERULE);
		         	entityFieldError.setErrorInfo(strRuleInfo);
		         	return entityFieldError;
            }
		}
		else
		{
		}
		return null;
	}
	

	/**
	 * 获取属性[YX]值错误
	 * @param bBaseMode 是否为基本检查模式，基本检查模式执行值类型，长度及属性值规则检查，非基本模式进行重复值检查
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据
	 * @param bTempMode 是否为临时数据模式
	 * @throws Exception
	 */
	protected EntityFieldError onCheckField_YX(boolean bBaseMode,GG_CARD et, boolean bCreate, boolean bTempMode) throws Exception
	{
		//判断是否有值	
		if(!et.isYXDirty())
			return null;
		
		String value = et.getYX();
		if(bBaseMode)
		{
			if(bCreate)
			{
			}
			
			String strRuleInfo  = null;
			//检查值规则[默认规则]
			strRuleInfo =onTestValueRule_YX_Default( et,  bCreate,  bTempMode);
			if(!StringHelper.isNullOrEmpty(strRuleInfo))
            {
           	 		EntityFieldError entityFieldError = new EntityFieldError();
           	 		entityFieldError.setFieldName(GG_CARD.FIELD_YX);
           	 		entityFieldError.setErrorType(EntityFieldError.ERROR_VALUERULE);
		         	entityFieldError.setErrorInfo(strRuleInfo);
		         	return entityFieldError;
            }
		}
		else
		{
		}
		return null;
	}
	

	/**
	 * 获取属性[SJZH]值错误
	 * @param bBaseMode 是否为基本检查模式，基本检查模式执行值类型，长度及属性值规则检查，非基本模式进行重复值检查
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据
	 * @param bTempMode 是否为临时数据模式
	 * @throws Exception
	 */
	protected EntityFieldError onCheckField_SJZH(boolean bBaseMode,GG_CARD et, boolean bCreate, boolean bTempMode) throws Exception
	{
		//判断是否有值	
		if(!et.isSJZHDirty())
			return null;
		
		String value = et.getSJZH();
		if(bBaseMode)
		{
			if(bCreate)
			{
			}
			
			String strRuleInfo  = null;
			//检查值规则[默认规则]
			strRuleInfo =onTestValueRule_SJZH_Default( et,  bCreate,  bTempMode);
			if(!StringHelper.isNullOrEmpty(strRuleInfo))
            {
           	 		EntityFieldError entityFieldError = new EntityFieldError();
           	 		entityFieldError.setFieldName(GG_CARD.FIELD_SJZH);
           	 		entityFieldError.setErrorType(EntityFieldError.ERROR_VALUERULE);
		         	entityFieldError.setErrorInfo(strRuleInfo);
		         	return entityFieldError;
            }
		}
		else
		{
		}
		return null;
	}
	

	/**
	 * 获取属性[ZD]值错误
	 * @param bBaseMode 是否为基本检查模式，基本检查模式执行值类型，长度及属性值规则检查，非基本模式进行重复值检查
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据
	 * @param bTempMode 是否为临时数据模式
	 * @throws Exception
	 */
	protected EntityFieldError onCheckField_ZD(boolean bBaseMode,GG_CARD et, boolean bCreate, boolean bTempMode) throws Exception
	{
		//判断是否有值	
		if(!et.isZDDirty())
			return null;
		
		String value = et.getZD();
		if(bBaseMode)
		{
			if(bCreate)
			{
			}
			
			String strRuleInfo  = null;
			//检查值规则[默认规则]
			strRuleInfo =onTestValueRule_ZD_Default( et,  bCreate,  bTempMode);
			if(!StringHelper.isNullOrEmpty(strRuleInfo))
            {
           	 		EntityFieldError entityFieldError = new EntityFieldError();
           	 		entityFieldError.setFieldName(GG_CARD.FIELD_ZD);
           	 		entityFieldError.setErrorType(EntityFieldError.ERROR_VALUERULE);
		         	entityFieldError.setErrorInfo(strRuleInfo);
		         	return entityFieldError;
            }
		}
		else
		{
		}
		return null;
	}
	

	/**
	 * 获取属性[HKGJ]值错误
	 * @param bBaseMode 是否为基本检查模式，基本检查模式执行值类型，长度及属性值规则检查，非基本模式进行重复值检查
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据
	 * @param bTempMode 是否为临时数据模式
	 * @throws Exception
	 */
	protected EntityFieldError onCheckField_HKGJ(boolean bBaseMode,GG_CARD et, boolean bCreate, boolean bTempMode) throws Exception
	{
		//判断是否有值	
		if(!et.isHKGJDirty())
			return null;
		
		String value = et.getHKGJ();
		if(bBaseMode)
		{
			if(bCreate)
			{
			}
			
			String strRuleInfo  = null;
			//检查值规则[默认规则]
			strRuleInfo =onTestValueRule_HKGJ_Default( et,  bCreate,  bTempMode);
			if(!StringHelper.isNullOrEmpty(strRuleInfo))
            {
           	 		EntityFieldError entityFieldError = new EntityFieldError();
           	 		entityFieldError.setFieldName(GG_CARD.FIELD_HKGJ);
           	 		entityFieldError.setErrorType(EntityFieldError.ERROR_VALUERULE);
		         	entityFieldError.setErrorInfo(strRuleInfo);
		         	return entityFieldError;
            }
		}
		else
		{
		}
		return null;
	}
	

	/**
	 * 获取属性[HYZT]值错误
	 * @param bBaseMode 是否为基本检查模式，基本检查模式执行值类型，长度及属性值规则检查，非基本模式进行重复值检查
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据
	 * @param bTempMode 是否为临时数据模式
	 * @throws Exception
	 */
	protected EntityFieldError onCheckField_HYZT(boolean bBaseMode,GG_CARD et, boolean bCreate, boolean bTempMode) throws Exception
	{
		//判断是否有值	
		if(!et.isHYZTDirty())
			return null;
		
		String value = et.getHYZT();
		if(bBaseMode)
		{
			if(bCreate)
			{
			}
			
			String strRuleInfo  = null;
			//检查值规则[默认规则]
			strRuleInfo =onTestValueRule_HYZT_Default( et,  bCreate,  bTempMode);
			if(!StringHelper.isNullOrEmpty(strRuleInfo))
            {
           	 		EntityFieldError entityFieldError = new EntityFieldError();
           	 		entityFieldError.setFieldName(GG_CARD.FIELD_HYZT);
           	 		entityFieldError.setErrorType(EntityFieldError.ERROR_VALUERULE);
		         	entityFieldError.setErrorInfo(strRuleInfo);
		         	return entityFieldError;
            }
		}
		else
		{
		}
		return null;
	}
	

	/**
	 * 获取属性[ZJH]值错误
	 * @param bBaseMode 是否为基本检查模式，基本检查模式执行值类型，长度及属性值规则检查，非基本模式进行重复值检查
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据
	 * @param bTempMode 是否为临时数据模式
	 * @throws Exception
	 */
	protected EntityFieldError onCheckField_ZJH(boolean bBaseMode,GG_CARD et, boolean bCreate, boolean bTempMode) throws Exception
	{
		//判断是否有值	
		if(!et.isZJHDirty())
			return null;
		
		String value = et.getZJH();
		if(bBaseMode)
		{
			if(bCreate)
			{
			}
			
			String strRuleInfo  = null;
			//检查值规则[默认规则]
			strRuleInfo =onTestValueRule_ZJH_Default( et,  bCreate,  bTempMode);
			if(!StringHelper.isNullOrEmpty(strRuleInfo))
            {
           	 		EntityFieldError entityFieldError = new EntityFieldError();
           	 		entityFieldError.setFieldName(GG_CARD.FIELD_ZJH);
           	 		entityFieldError.setErrorType(EntityFieldError.ERROR_VALUERULE);
		         	entityFieldError.setErrorInfo(strRuleInfo);
		         	return entityFieldError;
            }
		}
		else
		{
		}
		return null;
	}
	

	/**
	 * 获取属性[ZZMM]值错误
	 * @param bBaseMode 是否为基本检查模式，基本检查模式执行值类型，长度及属性值规则检查，非基本模式进行重复值检查
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据
	 * @param bTempMode 是否为临时数据模式
	 * @throws Exception
	 */
	protected EntityFieldError onCheckField_ZZMM(boolean bBaseMode,GG_CARD et, boolean bCreate, boolean bTempMode) throws Exception
	{
		//判断是否有值	
		if(!et.isZZMMDirty())
			return null;
		
		String value = et.getZZMM();
		if(bBaseMode)
		{
			if(bCreate)
			{
			}
			
			String strRuleInfo  = null;
			//检查值规则[默认规则]
			strRuleInfo =onTestValueRule_ZZMM_Default( et,  bCreate,  bTempMode);
			if(!StringHelper.isNullOrEmpty(strRuleInfo))
            {
           	 		EntityFieldError entityFieldError = new EntityFieldError();
           	 		entityFieldError.setFieldName(GG_CARD.FIELD_ZZMM);
           	 		entityFieldError.setErrorType(EntityFieldError.ERROR_VALUERULE);
		         	entityFieldError.setErrorInfo(strRuleInfo);
		         	return entityFieldError;
            }
		}
		else
		{
		}
		return null;
	}
	

	/**
	 * 获取属性[QTLXFS]值错误
	 * @param bBaseMode 是否为基本检查模式，基本检查模式执行值类型，长度及属性值规则检查，非基本模式进行重复值检查
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据
	 * @param bTempMode 是否为临时数据模式
	 * @throws Exception
	 */
	protected EntityFieldError onCheckField_QTLXFS(boolean bBaseMode,GG_CARD et, boolean bCreate, boolean bTempMode) throws Exception
	{
		//判断是否有值	
		if(!et.isQTLXFSDirty())
			return null;
		
		String value = et.getQTLXFS();
		if(bBaseMode)
		{
			if(bCreate)
			{
			}
			
			String strRuleInfo  = null;
			//检查值规则[默认规则]
			strRuleInfo =onTestValueRule_QTLXFS_Default( et,  bCreate,  bTempMode);
			if(!StringHelper.isNullOrEmpty(strRuleInfo))
            {
           	 		EntityFieldError entityFieldError = new EntityFieldError();
           	 		entityFieldError.setFieldName(GG_CARD.FIELD_QTLXFS);
           	 		entityFieldError.setErrorType(EntityFieldError.ERROR_VALUERULE);
		         	entityFieldError.setErrorInfo(strRuleInfo);
		         	return entityFieldError;
            }
		}
		else
		{
		}
		return null;
	}
	

	/**
	 * 获取属性[SG]值错误
	 * @param bBaseMode 是否为基本检查模式，基本检查模式执行值类型，长度及属性值规则检查，非基本模式进行重复值检查
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据
	 * @param bTempMode 是否为临时数据模式
	 * @throws Exception
	 */
	protected EntityFieldError onCheckField_SG(boolean bBaseMode,GG_CARD et, boolean bCreate, boolean bTempMode) throws Exception
	{
		//判断是否有值	
		if(!et.isSGDirty())
			return null;
		
		Integer value = et.getSG();
		if(bBaseMode)
		{
			if(bCreate)
			{
			}
			
			String strRuleInfo  = null;
			//检查值规则[默认规则]
			strRuleInfo =onTestValueRule_SG_Default( et,  bCreate,  bTempMode);
			if(!StringHelper.isNullOrEmpty(strRuleInfo))
            {
           	 		EntityFieldError entityFieldError = new EntityFieldError();
           	 		entityFieldError.setFieldName(GG_CARD.FIELD_SG);
           	 		entityFieldError.setErrorType(EntityFieldError.ERROR_VALUERULE);
		         	entityFieldError.setErrorInfo(strRuleInfo);
		         	return entityFieldError;
            }
		}
		else
		{
		}
		return null;
	}
	

	/**
	 * 获取属性[JTZZ]值错误
	 * @param bBaseMode 是否为基本检查模式，基本检查模式执行值类型，长度及属性值规则检查，非基本模式进行重复值检查
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据
	 * @param bTempMode 是否为临时数据模式
	 * @throws Exception
	 */
	protected EntityFieldError onCheckField_JTZZ(boolean bBaseMode,GG_CARD et, boolean bCreate, boolean bTempMode) throws Exception
	{
		//判断是否有值	
		if(!et.isJTZZDirty())
			return null;
		
		String value = et.getJTZZ();
		if(bBaseMode)
		{
			if(bCreate)
			{
			}
			
			String strRuleInfo  = null;
			//检查值规则[默认规则]
			strRuleInfo =onTestValueRule_JTZZ_Default( et,  bCreate,  bTempMode);
			if(!StringHelper.isNullOrEmpty(strRuleInfo))
            {
           	 		EntityFieldError entityFieldError = new EntityFieldError();
           	 		entityFieldError.setFieldName(GG_CARD.FIELD_JTZZ);
           	 		entityFieldError.setErrorType(EntityFieldError.ERROR_VALUERULE);
		         	entityFieldError.setErrorInfo(strRuleInfo);
		         	return entityFieldError;
            }
		}
		else
		{
		}
		return null;
	}
	

	/**
	 * 获取属性[GRZY]值错误
	 * @param bBaseMode 是否为基本检查模式，基本检查模式执行值类型，长度及属性值规则检查，非基本模式进行重复值检查
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据
	 * @param bTempMode 是否为临时数据模式
	 * @throws Exception
	 */
	protected EntityFieldError onCheckField_GRZY(boolean bBaseMode,GG_CARD et, boolean bCreate, boolean bTempMode) throws Exception
	{
		//判断是否有值	
		if(!et.isGRZYDirty())
			return null;
		
		String value = et.getGRZY();
		if(bBaseMode)
		{
			if(bCreate)
			{
			}
			
			String strRuleInfo  = null;
			//检查值规则[默认规则]
			strRuleInfo =onTestValueRule_GRZY_Default( et,  bCreate,  bTempMode);
			if(!StringHelper.isNullOrEmpty(strRuleInfo))
            {
           	 		EntityFieldError entityFieldError = new EntityFieldError();
           	 		entityFieldError.setFieldName(GG_CARD.FIELD_GRZY);
           	 		entityFieldError.setErrorType(EntityFieldError.ERROR_VALUERULE);
		         	entityFieldError.setErrorInfo(strRuleInfo);
		         	return entityFieldError;
            }
		}
		else
		{
		}
		return null;
	}
	

	/**
	 * 获取属性[MQNSR]值错误
	 * @param bBaseMode 是否为基本检查模式，基本检查模式执行值类型，长度及属性值规则检查，非基本模式进行重复值检查
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据
	 * @param bTempMode 是否为临时数据模式
	 * @throws Exception
	 */
	protected EntityFieldError onCheckField_MQNSR(boolean bBaseMode,GG_CARD et, boolean bCreate, boolean bTempMode) throws Exception
	{
		//判断是否有值	
		if(!et.isMQNSRDirty())
			return null;
		
		String value = et.getMQNSR();
		if(bBaseMode)
		{
			if(bCreate)
			{
			}
			
			String strRuleInfo  = null;
			//检查值规则[默认规则]
			strRuleInfo =onTestValueRule_MQNSR_Default( et,  bCreate,  bTempMode);
			if(!StringHelper.isNullOrEmpty(strRuleInfo))
            {
           	 		EntityFieldError entityFieldError = new EntityFieldError();
           	 		entityFieldError.setFieldName(GG_CARD.FIELD_MQNSR);
           	 		entityFieldError.setErrorType(EntityFieldError.ERROR_VALUERULE);
		         	entityFieldError.setErrorInfo(strRuleInfo);
		         	return entityFieldError;
            }
		}
		else
		{
		}
		return null;
	}
	

	/**
	 * 获取属性[JBGZ]值错误
	 * @param bBaseMode 是否为基本检查模式，基本检查模式执行值类型，长度及属性值规则检查，非基本模式进行重复值检查
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据
	 * @param bTempMode 是否为临时数据模式
	 * @throws Exception
	 */
	protected EntityFieldError onCheckField_JBGZ(boolean bBaseMode,GG_CARD et, boolean bCreate, boolean bTempMode) throws Exception
	{
		//判断是否有值	
		if(!et.isJBGZDirty())
			return null;
		
		String value = et.getJBGZ();
		if(bBaseMode)
		{
			if(bCreate)
			{
			}
			
			String strRuleInfo  = null;
			//检查值规则[默认规则]
			strRuleInfo =onTestValueRule_JBGZ_Default( et,  bCreate,  bTempMode);
			if(!StringHelper.isNullOrEmpty(strRuleInfo))
            {
           	 		EntityFieldError entityFieldError = new EntityFieldError();
           	 		entityFieldError.setFieldName(GG_CARD.FIELD_JBGZ);
           	 		entityFieldError.setErrorType(EntityFieldError.ERROR_VALUERULE);
		         	entityFieldError.setErrorInfo(strRuleInfo);
		         	return entityFieldError;
            }
		}
		else
		{
		}
		return null;
	}
	

	/**
	 * 获取属性[BTJT]值错误
	 * @param bBaseMode 是否为基本检查模式，基本检查模式执行值类型，长度及属性值规则检查，非基本模式进行重复值检查
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据
	 * @param bTempMode 是否为临时数据模式
	 * @throws Exception
	 */
	protected EntityFieldError onCheckField_BTJT(boolean bBaseMode,GG_CARD et, boolean bCreate, boolean bTempMode) throws Exception
	{
		//判断是否有值	
		if(!et.isBTJTDirty())
			return null;
		
		String value = et.getBTJT();
		if(bBaseMode)
		{
			if(bCreate)
			{
			}
			
			String strRuleInfo  = null;
			//检查值规则[默认规则]
			strRuleInfo =onTestValueRule_BTJT_Default( et,  bCreate,  bTempMode);
			if(!StringHelper.isNullOrEmpty(strRuleInfo))
            {
           	 		EntityFieldError entityFieldError = new EntityFieldError();
           	 		entityFieldError.setFieldName(GG_CARD.FIELD_BTJT);
           	 		entityFieldError.setErrorType(EntityFieldError.ERROR_VALUERULE);
		         	entityFieldError.setErrorInfo(strRuleInfo);
		         	return entityFieldError;
            }
		}
		else
		{
		}
		return null;
	}
	

	/**
	 * 获取属性[JJYJ]值错误
	 * @param bBaseMode 是否为基本检查模式，基本检查模式执行值类型，长度及属性值规则检查，非基本模式进行重复值检查
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据
	 * @param bTempMode 是否为临时数据模式
	 * @throws Exception
	 */
	protected EntityFieldError onCheckField_JJYJ(boolean bBaseMode,GG_CARD et, boolean bCreate, boolean bTempMode) throws Exception
	{
		//判断是否有值	
		if(!et.isJJYJDirty())
			return null;
		
		String value = et.getJJYJ();
		if(bBaseMode)
		{
			if(bCreate)
			{
			}
			
			String strRuleInfo  = null;
			//检查值规则[默认规则]
			strRuleInfo =onTestValueRule_JJYJ_Default( et,  bCreate,  bTempMode);
			if(!StringHelper.isNullOrEmpty(strRuleInfo))
            {
           	 		EntityFieldError entityFieldError = new EntityFieldError();
           	 		entityFieldError.setFieldName(GG_CARD.FIELD_JJYJ);
           	 		entityFieldError.setErrorType(EntityFieldError.ERROR_VALUERULE);
		         	entityFieldError.setErrorInfo(strRuleInfo);
		         	return entityFieldError;
            }
		}
		else
		{
		}
		return null;
	}
	

	/**
	 * 获取属性[GQSY]值错误
	 * @param bBaseMode 是否为基本检查模式，基本检查模式执行值类型，长度及属性值规则检查，非基本模式进行重复值检查
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据
	 * @param bTempMode 是否为临时数据模式
	 * @throws Exception
	 */
	protected EntityFieldError onCheckField_GQSY(boolean bBaseMode,GG_CARD et, boolean bCreate, boolean bTempMode) throws Exception
	{
		//判断是否有值	
		if(!et.isGQSYDirty())
			return null;
		
		String value = et.getGQSY();
		if(bBaseMode)
		{
			if(bCreate)
			{
			}
			
			String strRuleInfo  = null;
			//检查值规则[默认规则]
			strRuleInfo =onTestValueRule_GQSY_Default( et,  bCreate,  bTempMode);
			if(!StringHelper.isNullOrEmpty(strRuleInfo))
            {
           	 		EntityFieldError entityFieldError = new EntityFieldError();
           	 		entityFieldError.setFieldName(GG_CARD.FIELD_GQSY);
           	 		entityFieldError.setErrorType(EntityFieldError.ERROR_VALUERULE);
		         	entityFieldError.setErrorInfo(strRuleInfo);
		         	return entityFieldError;
            }
		}
		else
		{
		}
		return null;
	}
	

	/**
	 * 获取属性[QWNX]值错误
	 * @param bBaseMode 是否为基本检查模式，基本检查模式执行值类型，长度及属性值规则检查，非基本模式进行重复值检查
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据
	 * @param bTempMode 是否为临时数据模式
	 * @throws Exception
	 */
	protected EntityFieldError onCheckField_QWNX(boolean bBaseMode,GG_CARD et, boolean bCreate, boolean bTempMode) throws Exception
	{
		//判断是否有值	
		if(!et.isQWNXDirty())
			return null;
		
		String value = et.getQWNX();
		if(bBaseMode)
		{
			if(bCreate)
			{
			}
			
			String strRuleInfo  = null;
			//检查值规则[默认规则]
			strRuleInfo =onTestValueRule_QWNX_Default( et,  bCreate,  bTempMode);
			if(!StringHelper.isNullOrEmpty(strRuleInfo))
            {
           	 		EntityFieldError entityFieldError = new EntityFieldError();
           	 		entityFieldError.setFieldName(GG_CARD.FIELD_QWNX);
           	 		entityFieldError.setErrorType(EntityFieldError.ERROR_VALUERULE);
		         	entityFieldError.setErrorInfo(strRuleInfo);
		         	return entityFieldError;
            }
		}
		else
		{
		}
		return null;
	}
	

	/**
	 * 获取属性[DD]值错误
	 * @param bBaseMode 是否为基本检查模式，基本检查模式执行值类型，长度及属性值规则检查，非基本模式进行重复值检查
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据
	 * @param bTempMode 是否为临时数据模式
	 * @throws Exception
	 */
	protected EntityFieldError onCheckField_DD(boolean bBaseMode,GG_CARD et, boolean bCreate, boolean bTempMode) throws Exception
	{
		//判断是否有值	
		if(!et.isDDDirty())
			return null;
		
		String value = et.getDD();
		if(bBaseMode)
		{
			if(bCreate)
			{
			}
			
			String strRuleInfo  = null;
			//检查值规则[默认规则]
			strRuleInfo =onTestValueRule_DD_Default( et,  bCreate,  bTempMode);
			if(!StringHelper.isNullOrEmpty(strRuleInfo))
            {
           	 		EntityFieldError entityFieldError = new EntityFieldError();
           	 		entityFieldError.setFieldName(GG_CARD.FIELD_DD);
           	 		entityFieldError.setErrorType(EntityFieldError.ERROR_VALUERULE);
		         	entityFieldError.setErrorInfo(strRuleInfo);
		         	return entityFieldError;
            }
		}
		else
		{
		}
		return null;
	}
	

	/**
	 * 获取属性[HY]值错误
	 * @param bBaseMode 是否为基本检查模式，基本检查模式执行值类型，长度及属性值规则检查，非基本模式进行重复值检查
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据
	 * @param bTempMode 是否为临时数据模式
	 * @throws Exception
	 */
	protected EntityFieldError onCheckField_HY(boolean bBaseMode,GG_CARD et, boolean bCreate, boolean bTempMode) throws Exception
	{
		//判断是否有值	
		if(!et.isHYDirty())
			return null;
		
		String value = et.getHY();
		if(bBaseMode)
		{
			if(bCreate)
			{
			}
			
			String strRuleInfo  = null;
			//检查值规则[默认规则]
			strRuleInfo =onTestValueRule_HY_Default( et,  bCreate,  bTempMode);
			if(!StringHelper.isNullOrEmpty(strRuleInfo))
            {
           	 		EntityFieldError entityFieldError = new EntityFieldError();
           	 		entityFieldError.setFieldName(GG_CARD.FIELD_HY);
           	 		entityFieldError.setErrorType(EntityFieldError.ERROR_VALUERULE);
		         	entityFieldError.setErrorInfo(strRuleInfo);
		         	return entityFieldError;
            }
		}
		else
		{
		}
		return null;
	}
	

	/**
	 * 获取属性[ZGXL]值错误
	 * @param bBaseMode 是否为基本检查模式，基本检查模式执行值类型，长度及属性值规则检查，非基本模式进行重复值检查
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据
	 * @param bTempMode 是否为临时数据模式
	 * @throws Exception
	 */
	protected EntityFieldError onCheckField_ZGXL(boolean bBaseMode,GG_CARD et, boolean bCreate, boolean bTempMode) throws Exception
	{
		//判断是否有值	
		if(!et.isZGXLDirty())
			return null;
		
		String value = et.getZGXL();
		if(bBaseMode)
		{
			if(bCreate)
			{
			}
			
			String strRuleInfo  = null;
			//检查值规则[默认规则]
			strRuleInfo =onTestValueRule_ZGXL_Default( et,  bCreate,  bTempMode);
			if(!StringHelper.isNullOrEmpty(strRuleInfo))
            {
           	 		EntityFieldError entityFieldError = new EntityFieldError();
           	 		entityFieldError.setFieldName(GG_CARD.FIELD_ZGXL);
           	 		entityFieldError.setErrorType(EntityFieldError.ERROR_VALUERULE);
		         	entityFieldError.setErrorInfo(strRuleInfo);
		         	return entityFieldError;
            }
		}
		else
		{
		}
		return null;
	}
	

	/**
	 * 获取属性[ZN]值错误
	 * @param bBaseMode 是否为基本检查模式，基本检查模式执行值类型，长度及属性值规则检查，非基本模式进行重复值检查
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据
	 * @param bTempMode 是否为临时数据模式
	 * @throws Exception
	 */
	protected EntityFieldError onCheckField_ZN(boolean bBaseMode,GG_CARD et, boolean bCreate, boolean bTempMode) throws Exception
	{
		//判断是否有值	
		if(!et.isZNDirty())
			return null;
		
		String value = et.getZN();
		if(bBaseMode)
		{
			if(bCreate)
			{
			}
			
			String strRuleInfo  = null;
			//检查值规则[默认规则]
			strRuleInfo =onTestValueRule_ZN_Default( et,  bCreate,  bTempMode);
			if(!StringHelper.isNullOrEmpty(strRuleInfo))
            {
           	 		EntityFieldError entityFieldError = new EntityFieldError();
           	 		entityFieldError.setFieldName(GG_CARD.FIELD_ZN);
           	 		entityFieldError.setErrorType(EntityFieldError.ERROR_VALUERULE);
		         	entityFieldError.setErrorInfo(strRuleInfo);
		         	return entityFieldError;
            }
		}
		else
		{
		}
		return null;
	}
	

	/**
	 * 获取属性[Zn_fdc]值错误
	 * @param bBaseMode 是否为基本检查模式，基本检查模式执行值类型，长度及属性值规则检查，非基本模式进行重复值检查
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据
	 * @param bTempMode 是否为临时数据模式
	 * @throws Exception
	 */
	protected EntityFieldError onCheckField_Zn_fdc(boolean bBaseMode,GG_CARD et, boolean bCreate, boolean bTempMode) throws Exception
	{
		//判断是否有值	
		if(!et.isZn_fdcDirty())
			return null;
		
		String value = et.getZn_fdc();
		if(bBaseMode)
		{
			if(bCreate)
			{
			}
			
			String strRuleInfo  = null;
			//检查值规则[默认规则]
			strRuleInfo =onTestValueRule_Zn_fdc_Default( et,  bCreate,  bTempMode);
			if(!StringHelper.isNullOrEmpty(strRuleInfo))
            {
           	 		EntityFieldError entityFieldError = new EntityFieldError();
           	 		entityFieldError.setFieldName(GG_CARD.FIELD_ZN_FDC);
           	 		entityFieldError.setErrorType(EntityFieldError.ERROR_VALUERULE);
		         	entityFieldError.setErrorInfo(strRuleInfo);
		         	return entityFieldError;
            }
		}
		else
		{
		}
		return null;
	}
	

	/**
	 * 获取属性[Zn_hlw]值错误
	 * @param bBaseMode 是否为基本检查模式，基本检查模式执行值类型，长度及属性值规则检查，非基本模式进行重复值检查
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据
	 * @param bTempMode 是否为临时数据模式
	 * @throws Exception
	 */
	protected EntityFieldError onCheckField_Zn_hlw(boolean bBaseMode,GG_CARD et, boolean bCreate, boolean bTempMode) throws Exception
	{
		//判断是否有值	
		if(!et.isZn_hlwDirty())
			return null;
		
		String value = et.getZn_hlw();
		if(bBaseMode)
		{
			if(bCreate)
			{
			}
			
			String strRuleInfo  = null;
			//检查值规则[默认规则]
			strRuleInfo =onTestValueRule_Zn_hlw_Default( et,  bCreate,  bTempMode);
			if(!StringHelper.isNullOrEmpty(strRuleInfo))
            {
           	 		EntityFieldError entityFieldError = new EntityFieldError();
           	 		entityFieldError.setFieldName(GG_CARD.FIELD_ZN_HLW);
           	 		entityFieldError.setErrorType(EntityFieldError.ERROR_VALUERULE);
		         	entityFieldError.setErrorInfo(strRuleInfo);
		         	return entityFieldError;
            }
		}
		else
		{
		}
		return null;
	}
	

	/**
	 * 获取属性[Zn_jryh]值错误
	 * @param bBaseMode 是否为基本检查模式，基本检查模式执行值类型，长度及属性值规则检查，非基本模式进行重复值检查
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据
	 * @param bTempMode 是否为临时数据模式
	 * @throws Exception
	 */
	protected EntityFieldError onCheckField_Zn_jryh(boolean bBaseMode,GG_CARD et, boolean bCreate, boolean bTempMode) throws Exception
	{
		//判断是否有值	
		if(!et.isZn_jryhDirty())
			return null;
		
		String value = et.getZn_jryh();
		if(bBaseMode)
		{
			if(bCreate)
			{
			}
			
			String strRuleInfo  = null;
			//检查值规则[默认规则]
			strRuleInfo =onTestValueRule_Zn_jryh_Default( et,  bCreate,  bTempMode);
			if(!StringHelper.isNullOrEmpty(strRuleInfo))
            {
           	 		EntityFieldError entityFieldError = new EntityFieldError();
           	 		entityFieldError.setFieldName(GG_CARD.FIELD_ZN_JRYH);
           	 		entityFieldError.setErrorType(EntityFieldError.ERROR_VALUERULE);
		         	entityFieldError.setErrorInfo(strRuleInfo);
		         	return entityFieldError;
            }
		}
		else
		{
		}
		return null;
	}
	

	/**
	 * 获取属性[Zn_jxzz]值错误
	 * @param bBaseMode 是否为基本检查模式，基本检查模式执行值类型，长度及属性值规则检查，非基本模式进行重复值检查
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据
	 * @param bTempMode 是否为临时数据模式
	 * @throws Exception
	 */
	protected EntityFieldError onCheckField_Zn_jxzz(boolean bBaseMode,GG_CARD et, boolean bCreate, boolean bTempMode) throws Exception
	{
		//判断是否有值	
		if(!et.isZn_jxzzDirty())
			return null;
		
		String value = et.getZn_jxzz();
		if(bBaseMode)
		{
			if(bCreate)
			{
			}
			
			String strRuleInfo  = null;
			//检查值规则[默认规则]
			strRuleInfo =onTestValueRule_Zn_jxzz_Default( et,  bCreate,  bTempMode);
			if(!StringHelper.isNullOrEmpty(strRuleInfo))
            {
           	 		EntityFieldError entityFieldError = new EntityFieldError();
           	 		entityFieldError.setFieldName(GG_CARD.FIELD_ZN_JXZZ);
           	 		entityFieldError.setErrorType(EntityFieldError.ERROR_VALUERULE);
		         	entityFieldError.setErrorInfo(strRuleInfo);
		         	return entityFieldError;
            }
		}
		else
		{
		}
		return null;
	}
	

	/**
	 * 获取属性[Zn_swyy]值错误
	 * @param bBaseMode 是否为基本检查模式，基本检查模式执行值类型，长度及属性值规则检查，非基本模式进行重复值检查
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据
	 * @param bTempMode 是否为临时数据模式
	 * @throws Exception
	 */
	protected EntityFieldError onCheckField_Zn_swyy(boolean bBaseMode,GG_CARD et, boolean bCreate, boolean bTempMode) throws Exception
	{
		//判断是否有值	
		if(!et.isZn_swyyDirty())
			return null;
		
		String value = et.getZn_swyy();
		if(bBaseMode)
		{
			if(bCreate)
			{
			}
			
			String strRuleInfo  = null;
			//检查值规则[默认规则]
			strRuleInfo =onTestValueRule_Zn_swyy_Default( et,  bCreate,  bTempMode);
			if(!StringHelper.isNullOrEmpty(strRuleInfo))
            {
           	 		EntityFieldError entityFieldError = new EntityFieldError();
           	 		entityFieldError.setFieldName(GG_CARD.FIELD_ZN_SWYY);
           	 		entityFieldError.setErrorType(EntityFieldError.ERROR_VALUERULE);
		         	entityFieldError.setErrorInfo(strRuleInfo);
		         	return entityFieldError;
            }
		}
		else
		{
		}
		return null;
	}
	

	/**
	 * 获取属性[Zn_syls]值错误
	 * @param bBaseMode 是否为基本检查模式，基本检查模式执行值类型，长度及属性值规则检查，非基本模式进行重复值检查
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据
	 * @param bTempMode 是否为临时数据模式
	 * @throws Exception
	 */
	protected EntityFieldError onCheckField_Zn_syls(boolean bBaseMode,GG_CARD et, boolean bCreate, boolean bTempMode) throws Exception
	{
		//判断是否有值	
		if(!et.isZn_sylsDirty())
			return null;
		
		String value = et.getZn_syls();
		if(bBaseMode)
		{
			if(bCreate)
			{
			}
			
			String strRuleInfo  = null;
			//检查值规则[默认规则]
			strRuleInfo =onTestValueRule_Zn_syls_Default( et,  bCreate,  bTempMode);
			if(!StringHelper.isNullOrEmpty(strRuleInfo))
            {
           	 		EntityFieldError entityFieldError = new EntityFieldError();
           	 		entityFieldError.setFieldName(GG_CARD.FIELD_ZN_SYLS);
           	 		entityFieldError.setErrorType(EntityFieldError.ERROR_VALUERULE);
		         	entityFieldError.setErrorInfo(strRuleInfo);
		         	return entityFieldError;
            }
		}
		else
		{
		}
		return null;
	}
	

	/**
	 * 获取属性[GRBQ]值错误
	 * @param bBaseMode 是否为基本检查模式，基本检查模式执行值类型，长度及属性值规则检查，非基本模式进行重复值检查
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据
	 * @param bTempMode 是否为临时数据模式
	 * @throws Exception
	 */
	protected EntityFieldError onCheckField_GRBQ(boolean bBaseMode,GG_CARD et, boolean bCreate, boolean bTempMode) throws Exception
	{
		//判断是否有值	
		if(!et.isGRBQDirty())
			return null;
		
		String value = et.getGRBQ();
		if(bBaseMode)
		{
			if(bCreate)
			{
			}
			
			String strRuleInfo  = null;
			//检查值规则[默认规则]
			strRuleInfo =onTestValueRule_GRBQ_Default( et,  bCreate,  bTempMode);
			if(!StringHelper.isNullOrEmpty(strRuleInfo))
            {
           	 		EntityFieldError entityFieldError = new EntityFieldError();
           	 		entityFieldError.setFieldName(GG_CARD.FIELD_GRBQ);
           	 		entityFieldError.setErrorType(EntityFieldError.ERROR_VALUERULE);
		         	entityFieldError.setErrorInfo(strRuleInfo);
		         	return entityFieldError;
            }
		}
		else
		{
		}
		return null;
	}
	

	/**
	 * 获取属性[ZWPJ]值错误
	 * @param bBaseMode 是否为基本检查模式，基本检查模式执行值类型，长度及属性值规则检查，非基本模式进行重复值检查
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据
	 * @param bTempMode 是否为临时数据模式
	 * @throws Exception
	 */
	protected EntityFieldError onCheckField_ZWPJ(boolean bBaseMode,GG_CARD et, boolean bCreate, boolean bTempMode) throws Exception
	{
		//判断是否有值	
		if(!et.isZWPJDirty())
			return null;
		
		String value = et.getZWPJ();
		if(bBaseMode)
		{
			if(bCreate)
			{
			}
			
			String strRuleInfo  = null;
			//检查值规则[默认规则]
			strRuleInfo =onTestValueRule_ZWPJ_Default( et,  bCreate,  bTempMode);
			if(!StringHelper.isNullOrEmpty(strRuleInfo))
            {
           	 		EntityFieldError entityFieldError = new EntityFieldError();
           	 		entityFieldError.setFieldName(GG_CARD.FIELD_ZWPJ);
           	 		entityFieldError.setErrorType(EntityFieldError.ERROR_VALUERULE);
		         	entityFieldError.setErrorInfo(strRuleInfo);
		         	return entityFieldError;
            }
		}
		else
		{
		}
		return null;
	}
	

	/**
	 * 获取属性[DGSJ]值错误
	 * @param bBaseMode 是否为基本检查模式，基本检查模式执行值类型，长度及属性值规则检查，非基本模式进行重复值检查
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据
	 * @param bTempMode 是否为临时数据模式
	 * @throws Exception
	 */
	protected EntityFieldError onCheckField_DGSJ(boolean bBaseMode,GG_CARD et, boolean bCreate, boolean bTempMode) throws Exception
	{
		//判断是否有值	
		if(!et.isDGSJDirty())
			return null;
		
		Integer value = et.getDGSJ();
		if(bBaseMode)
		{
			if(bCreate)
			{
			}
			
			String strRuleInfo  = null;
			//检查值规则[默认规则]
			strRuleInfo =onTestValueRule_DGSJ_Default( et,  bCreate,  bTempMode);
			if(!StringHelper.isNullOrEmpty(strRuleInfo))
            {
           	 		EntityFieldError entityFieldError = new EntityFieldError();
           	 		entityFieldError.setFieldName(GG_CARD.FIELD_DGSJ);
           	 		entityFieldError.setErrorType(EntityFieldError.ERROR_VALUERULE);
		         	entityFieldError.setErrorInfo(strRuleInfo);
		         	return entityFieldError;
            }
		}
		else
		{
		}
		return null;
	}
	

	/**
	 * 获取属性[GZLX]值错误
	 * @param bBaseMode 是否为基本检查模式，基本检查模式执行值类型，长度及属性值规则检查，非基本模式进行重复值检查
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据
	 * @param bTempMode 是否为临时数据模式
	 * @throws Exception
	 */
	protected EntityFieldError onCheckField_GZLX(boolean bBaseMode,GG_CARD et, boolean bCreate, boolean bTempMode) throws Exception
	{
		//判断是否有值	
		if(!et.isGZLXDirty())
			return null;
		
		String value = et.getGZLX();
		if(bBaseMode)
		{
			if(bCreate)
			{
			}
			
			String strRuleInfo  = null;
			//检查值规则[默认规则]
			strRuleInfo =onTestValueRule_GZLX_Default( et,  bCreate,  bTempMode);
			if(!StringHelper.isNullOrEmpty(strRuleInfo))
            {
           	 		EntityFieldError entityFieldError = new EntityFieldError();
           	 		entityFieldError.setFieldName(GG_CARD.FIELD_GZLX);
           	 		entityFieldError.setErrorType(EntityFieldError.ERROR_VALUERULE);
		         	entityFieldError.setErrorInfo(strRuleInfo);
		         	return entityFieldError;
            }
		}
		else
		{
		}
		return null;
	}
	

	/**
	 * 获取属性[YTJQY]值错误
	 * @param bBaseMode 是否为基本检查模式，基本检查模式执行值类型，长度及属性值规则检查，非基本模式进行重复值检查
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据
	 * @param bTempMode 是否为临时数据模式
	 * @throws Exception
	 */
	protected EntityFieldError onCheckField_YTJQY(boolean bBaseMode,GG_CARD et, boolean bCreate, boolean bTempMode) throws Exception
	{
		//判断是否有值	
		if(!et.isYTJQYDirty())
			return null;
		
		String value = et.getYTJQY();
		if(bBaseMode)
		{
			if(bCreate)
			{
			}
			
			String strRuleInfo  = null;
			//检查值规则[默认规则]
			strRuleInfo =onTestValueRule_YTJQY_Default( et,  bCreate,  bTempMode);
			if(!StringHelper.isNullOrEmpty(strRuleInfo))
            {
           	 		EntityFieldError entityFieldError = new EntityFieldError();
           	 		entityFieldError.setFieldName(GG_CARD.FIELD_YTJQY);
           	 		entityFieldError.setErrorType(EntityFieldError.ERROR_VALUERULE);
		         	entityFieldError.setErrorInfo(strRuleInfo);
		         	return entityFieldError;
            }
		}
		else
		{
		}
		return null;
	}
	

	/**
	 * 获取属性[TJGWSZCS]值错误
	 * @param bBaseMode 是否为基本检查模式，基本检查模式执行值类型，长度及属性值规则检查，非基本模式进行重复值检查
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据
	 * @param bTempMode 是否为临时数据模式
	 * @throws Exception
	 */
	protected EntityFieldError onCheckField_TJGWSZCS(boolean bBaseMode,GG_CARD et, boolean bCreate, boolean bTempMode) throws Exception
	{
		//判断是否有值	
		if(!et.isTJGWSZCSDirty())
			return null;
		
		String value = et.getTJGWSZCS();
		if(bBaseMode)
		{
			if(bCreate)
			{
			}
			
			String strRuleInfo  = null;
			//检查值规则[默认规则]
			strRuleInfo =onTestValueRule_TJGWSZCS_Default( et,  bCreate,  bTempMode);
			if(!StringHelper.isNullOrEmpty(strRuleInfo))
            {
           	 		EntityFieldError entityFieldError = new EntityFieldError();
           	 		entityFieldError.setFieldName(GG_CARD.FIELD_TJGWSZCS);
           	 		entityFieldError.setErrorType(EntityFieldError.ERROR_VALUERULE);
		         	entityFieldError.setErrorInfo(strRuleInfo);
		         	return entityFieldError;
            }
		}
		else
		{
		}
		return null;
	}
	

	/**
	 * 获取属性[TJSJ]值错误
	 * @param bBaseMode 是否为基本检查模式，基本检查模式执行值类型，长度及属性值规则检查，非基本模式进行重复值检查
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据
	 * @param bTempMode 是否为临时数据模式
	 * @throws Exception
	 */
	protected EntityFieldError onCheckField_TJSJ(boolean bBaseMode,GG_CARD et, boolean bCreate, boolean bTempMode) throws Exception
	{
		//判断是否有值	
		if(!et.isTJSJDirty())
			return null;
		
		Timestamp value = et.getTJSJ();
		if(bBaseMode)
		{
			if(bCreate)
			{
			}
			
			String strRuleInfo  = null;
			//检查值规则[默认规则]
			strRuleInfo =onTestValueRule_TJSJ_Default( et,  bCreate,  bTempMode);
			if(!StringHelper.isNullOrEmpty(strRuleInfo))
            {
           	 		EntityFieldError entityFieldError = new EntityFieldError();
           	 		entityFieldError.setFieldName(GG_CARD.FIELD_TJSJ);
           	 		entityFieldError.setErrorType(EntityFieldError.ERROR_VALUERULE);
		         	entityFieldError.setErrorInfo(strRuleInfo);
		         	return entityFieldError;
            }
		}
		else
		{
		}
		return null;
	}
	

	/**
	 * 获取属性[ZP]值错误
	 * @param bBaseMode 是否为基本检查模式，基本检查模式执行值类型，长度及属性值规则检查，非基本模式进行重复值检查
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据
	 * @param bTempMode 是否为临时数据模式
	 * @throws Exception
	 */
	protected EntityFieldError onCheckField_ZP(boolean bBaseMode,GG_CARD et, boolean bCreate, boolean bTempMode) throws Exception
	{
		//判断是否有值	
		if(!et.isZPDirty())
			return null;
		
		String value = et.getZP();
		if(bBaseMode)
		{
			if(bCreate)
			{
			}
			
			String strRuleInfo  = null;
			//检查值规则[默认规则]
			strRuleInfo =onTestValueRule_ZP_Default( et,  bCreate,  bTempMode);
			if(!StringHelper.isNullOrEmpty(strRuleInfo))
            {
           	 		EntityFieldError entityFieldError = new EntityFieldError();
           	 		entityFieldError.setFieldName(GG_CARD.FIELD_ZP);
           	 		entityFieldError.setErrorType(EntityFieldError.ERROR_VALUERULE);
		         	entityFieldError.setErrorInfo(strRuleInfo);
		         	return entityFieldError;
            }
		}
		else
		{
		}
		return null;
	}
	

	

	/* (non-Javadoc)
	 * @see net.ibizsys.paas.service.ServiceBase#onSyncEntity(net.ibizsys.paas.entity.IEntity, boolean)
	 */
	@Override
	protected void onSyncEntity(GG_CARD et, boolean bRemove) throws Exception
	{
		super.onSyncEntity( et,  bRemove);
	}


	/* (non-Javadoc)
	 * @see net.ibizsys.paas.service.ServiceBase#onSyncIndexEntities(net.ibizsys.paas.entity.IEntity, boolean)
	 */
	@Override
	protected void onSyncIndexEntities(GG_CARD et,boolean bRemove) throws Exception
	{
		super.onSyncIndexEntities(et,bRemove);
	}


	/* (non-Javadoc)
	 * @see net.ibizsys.paas.service.ServiceBase#getDataContextValue(net.ibizsys.paas.entity.IEntity, java.lang.String, net.ibizsys.paas.service.IDataContextParam)
	 */
	@Override
	public Object getDataContextValue(GG_CARD et,String strField,IDataContextParam iDataContextParam)throws Exception
	{
		Object objValue = null;
		if(iDataContextParam!=null)
		{
		}
		
		objValue = super.getDataContextValue(et,strField,iDataContextParam);
		if(objValue!=null)
			return objValue;

		return null;
	}

	
	
	/* (non-Javadoc)
	 * @see net.ibizsys.paas.service.ServiceBase#onTestValueRule(java.lang.String, java.lang.String, net.ibizsys.paas.entity.IEntity, boolean, boolean)
	 */
	@Override
	protected String onTestValueRule(String strDEFieldName,String strRule,IEntity et,boolean bCreate,boolean bTempMode) throws Exception
	{
		if((StringHelper.compare(strDEFieldName,GG_CARD.FIELD_BTJT,true)==0)
				&&(StringHelper.compare(strRule,"DEFAULT",true)==0))
			return onTestValueRule_BTJT_Default(et,bCreate,bTempMode);
		if((StringHelper.compare(strDEFieldName,GG_CARD.FIELD_DGSJ,true)==0)
				&&(StringHelper.compare(strRule,"DEFAULT",true)==0))
			return onTestValueRule_DGSJ_Default(et,bCreate,bTempMode);
		if((StringHelper.compare(strDEFieldName,GG_CARD.FIELD_ZN_FDC,true)==0)
				&&(StringHelper.compare(strRule,"DEFAULT",true)==0))
			return onTestValueRule_Zn_fdc_Default(et,bCreate,bTempMode);
		if((StringHelper.compare(strDEFieldName,GG_CARD.FIELD_GG_WORKNAME,true)==0)
				&&(StringHelper.compare(strRule,"DEFAULT",true)==0))
			return onTestValueRule_GG_WORKName_Default(et,bCreate,bTempMode);
		if((StringHelper.compare(strDEFieldName,GG_CARD.FIELD_TJSJ,true)==0)
				&&(StringHelper.compare(strRule,"DEFAULT",true)==0))
			return onTestValueRule_TJSJ_Default(et,bCreate,bTempMode);
		if((StringHelper.compare(strDEFieldName,GG_CARD.FIELD_XM,true)==0)
				&&(StringHelper.compare(strRule,"DEFAULT",true)==0))
			return onTestValueRule_XM_Default(et,bCreate,bTempMode);
		if((StringHelper.compare(strDEFieldName,GG_CARD.FIELD_YTJQY,true)==0)
				&&(StringHelper.compare(strRule,"DEFAULT",true)==0))
			return onTestValueRule_YTJQY_Default(et,bCreate,bTempMode);
		if((StringHelper.compare(strDEFieldName,GG_CARD.FIELD_ZN_JRYH,true)==0)
				&&(StringHelper.compare(strRule,"DEFAULT",true)==0))
			return onTestValueRule_Zn_jryh_Default(et,bCreate,bTempMode);
		if((StringHelper.compare(strDEFieldName,GG_CARD.FIELD_TJGWSZCS,true)==0)
				&&(StringHelper.compare(strRule,"DEFAULT",true)==0))
			return onTestValueRule_TJGWSZCS_Default(et,bCreate,bTempMode);
		if((StringHelper.compare(strDEFieldName,GG_CARD.FIELD_ZP,true)==0)
				&&(StringHelper.compare(strRule,"DEFAULT",true)==0))
			return onTestValueRule_ZP_Default(et,bCreate,bTempMode);
		if((StringHelper.compare(strDEFieldName,GG_CARD.FIELD_UPDATEDATE,true)==0)
				&&(StringHelper.compare(strRule,"DEFAULT",true)==0))
			return onTestValueRule_UpdateDate_Default(et,bCreate,bTempMode);
		if((StringHelper.compare(strDEFieldName,GG_CARD.FIELD_ZN_SYLS,true)==0)
				&&(StringHelper.compare(strRule,"DEFAULT",true)==0))
			return onTestValueRule_Zn_syls_Default(et,bCreate,bTempMode);
		if((StringHelper.compare(strDEFieldName,GG_CARD.FIELD_HY,true)==0)
				&&(StringHelper.compare(strRule,"DEFAULT",true)==0))
			return onTestValueRule_HY_Default(et,bCreate,bTempMode);
		if((StringHelper.compare(strDEFieldName,GG_CARD.FIELD_NL,true)==0)
				&&(StringHelper.compare(strRule,"DEFAULT",true)==0))
			return onTestValueRule_NL_Default(et,bCreate,bTempMode);
		if((StringHelper.compare(strDEFieldName,GG_CARD.FIELD_ZJH,true)==0)
				&&(StringHelper.compare(strRule,"DEFAULT",true)==0))
			return onTestValueRule_ZJH_Default(et,bCreate,bTempMode);
		if((StringHelper.compare(strDEFieldName,GG_CARD.FIELD_QZZT,true)==0)
				&&(StringHelper.compare(strRule,"DEFAULT",true)==0))
			return onTestValueRule_QZZT_Default(et,bCreate,bTempMode);
		if((StringHelper.compare(strDEFieldName,GG_CARD.FIELD_ZZMM,true)==0)
				&&(StringHelper.compare(strRule,"DEFAULT",true)==0))
			return onTestValueRule_ZZMM_Default(et,bCreate,bTempMode);
		if((StringHelper.compare(strDEFieldName,GG_CARD.FIELD_XB,true)==0)
				&&(StringHelper.compare(strRule,"DEFAULT",true)==0))
			return onTestValueRule_XB_Default(et,bCreate,bTempMode);
		if((StringHelper.compare(strDEFieldName,GG_CARD.FIELD_ZN_JXZZ,true)==0)
				&&(StringHelper.compare(strRule,"DEFAULT",true)==0))
			return onTestValueRule_Zn_jxzz_Default(et,bCreate,bTempMode);
		if((StringHelper.compare(strDEFieldName,GG_CARD.FIELD_GZNX,true)==0)
				&&(StringHelper.compare(strRule,"DEFAULT",true)==0))
			return onTestValueRule_GZNX_Default(et,bCreate,bTempMode);
		if((StringHelper.compare(strDEFieldName,GG_CARD.FIELD_HYZT,true)==0)
				&&(StringHelper.compare(strRule,"DEFAULT",true)==0))
			return onTestValueRule_HYZT_Default(et,bCreate,bTempMode);
		if((StringHelper.compare(strDEFieldName,GG_CARD.FIELD_ZN_HLW,true)==0)
				&&(StringHelper.compare(strRule,"DEFAULT",true)==0))
			return onTestValueRule_Zn_hlw_Default(et,bCreate,bTempMode);
		if((StringHelper.compare(strDEFieldName,GG_CARD.FIELD_GRZY,true)==0)
				&&(StringHelper.compare(strRule,"DEFAULT",true)==0))
			return onTestValueRule_GRZY_Default(et,bCreate,bTempMode);
		if((StringHelper.compare(strDEFieldName,GG_CARD.FIELD_GG_CARDNAME,true)==0)
				&&(StringHelper.compare(strRule,"DEFAULT",true)==0))
			return onTestValueRule_GG_CARDName_Default(et,bCreate,bTempMode);
		if((StringHelper.compare(strDEFieldName,GG_CARD.FIELD_ZGXL,true)==0)
				&&(StringHelper.compare(strRule,"DEFAULT",true)==0))
			return onTestValueRule_ZGXL_Default(et,bCreate,bTempMode);
		if((StringHelper.compare(strDEFieldName,GG_CARD.FIELD_QTLXFS,true)==0)
				&&(StringHelper.compare(strRule,"DEFAULT",true)==0))
			return onTestValueRule_QTLXFS_Default(et,bCreate,bTempMode);
		if((StringHelper.compare(strDEFieldName,GG_CARD.FIELD_SJZH,true)==0)
				&&(StringHelper.compare(strRule,"DEFAULT",true)==0))
			return onTestValueRule_SJZH_Default(et,bCreate,bTempMode);
		if((StringHelper.compare(strDEFieldName,GG_CARD.FIELD_MQNSR,true)==0)
				&&(StringHelper.compare(strRule,"DEFAULT",true)==0))
			return onTestValueRule_MQNSR_Default(et,bCreate,bTempMode);
		if((StringHelper.compare(strDEFieldName,GG_CARD.FIELD_HKGJ,true)==0)
				&&(StringHelper.compare(strRule,"DEFAULT",true)==0))
			return onTestValueRule_HKGJ_Default(et,bCreate,bTempMode);
		if((StringHelper.compare(strDEFieldName,GG_CARD.FIELD_QWNX,true)==0)
				&&(StringHelper.compare(strRule,"DEFAULT",true)==0))
			return onTestValueRule_QWNX_Default(et,bCreate,bTempMode);
		if((StringHelper.compare(strDEFieldName,GG_CARD.FIELD_JJYJ,true)==0)
				&&(StringHelper.compare(strRule,"DEFAULT",true)==0))
			return onTestValueRule_JJYJ_Default(et,bCreate,bTempMode);
		if((StringHelper.compare(strDEFieldName,GG_CARD.FIELD_ZN_SWYY,true)==0)
				&&(StringHelper.compare(strRule,"DEFAULT",true)==0))
			return onTestValueRule_Zn_swyy_Default(et,bCreate,bTempMode);
		if((StringHelper.compare(strDEFieldName,GG_CARD.FIELD_JTZZ,true)==0)
				&&(StringHelper.compare(strRule,"DEFAULT",true)==0))
			return onTestValueRule_JTZZ_Default(et,bCreate,bTempMode);
		if((StringHelper.compare(strDEFieldName,GG_CARD.FIELD_GZLX,true)==0)
				&&(StringHelper.compare(strRule,"DEFAULT",true)==0))
			return onTestValueRule_GZLX_Default(et,bCreate,bTempMode);
		if((StringHelper.compare(strDEFieldName,GG_CARD.FIELD_SJ,true)==0)
				&&(StringHelper.compare(strRule,"DEFAULT",true)==0))
			return onTestValueRule_SJ_Default(et,bCreate,bTempMode);
		if((StringHelper.compare(strDEFieldName,GG_CARD.FIELD_CREATEDATE,true)==0)
				&&(StringHelper.compare(strRule,"DEFAULT",true)==0))
			return onTestValueRule_CreateDate_Default(et,bCreate,bTempMode);
		if((StringHelper.compare(strDEFieldName,GG_CARD.FIELD_KSGZNF,true)==0)
				&&(StringHelper.compare(strRule,"DEFAULT",true)==0))
			return onTestValueRule_KSGZNF_Default(et,bCreate,bTempMode);
		if((StringHelper.compare(strDEFieldName,GG_CARD.FIELD_CREATEMAN,true)==0)
				&&(StringHelper.compare(strRule,"DEFAULT",true)==0))
			return onTestValueRule_CreateMan_Default(et,bCreate,bTempMode);
		if((StringHelper.compare(strDEFieldName,GG_CARD.FIELD_SG,true)==0)
				&&(StringHelper.compare(strRule,"DEFAULT",true)==0))
			return onTestValueRule_SG_Default(et,bCreate,bTempMode);
		if((StringHelper.compare(strDEFieldName,GG_CARD.FIELD_GG_CARDID,true)==0)
				&&(StringHelper.compare(strRule,"DEFAULT",true)==0))
			return onTestValueRule_GG_CARDId_Default(et,bCreate,bTempMode);
		if((StringHelper.compare(strDEFieldName,GG_CARD.FIELD_JBGZ,true)==0)
				&&(StringHelper.compare(strRule,"DEFAULT",true)==0))
			return onTestValueRule_JBGZ_Default(et,bCreate,bTempMode);
		if((StringHelper.compare(strDEFieldName,GG_CARD.FIELD_UPDATEMAN,true)==0)
				&&(StringHelper.compare(strRule,"DEFAULT",true)==0))
			return onTestValueRule_UpdateMan_Default(et,bCreate,bTempMode);
		if((StringHelper.compare(strDEFieldName,GG_CARD.FIELD_ZD,true)==0)
				&&(StringHelper.compare(strRule,"DEFAULT",true)==0))
			return onTestValueRule_ZD_Default(et,bCreate,bTempMode);
		if((StringHelper.compare(strDEFieldName,GG_CARD.FIELD_DD,true)==0)
				&&(StringHelper.compare(strRule,"DEFAULT",true)==0))
			return onTestValueRule_DD_Default(et,bCreate,bTempMode);
		if((StringHelper.compare(strDEFieldName,GG_CARD.FIELD_GQSY,true)==0)
				&&(StringHelper.compare(strRule,"DEFAULT",true)==0))
			return onTestValueRule_GQSY_Default(et,bCreate,bTempMode);
		if((StringHelper.compare(strDEFieldName,GG_CARD.FIELD_YX,true)==0)
				&&(StringHelper.compare(strRule,"DEFAULT",true)==0))
			return onTestValueRule_YX_Default(et,bCreate,bTempMode);
		if((StringHelper.compare(strDEFieldName,GG_CARD.FIELD_CSRQ,true)==0)
				&&(StringHelper.compare(strRule,"DEFAULT",true)==0))
			return onTestValueRule_CSRQ_Default(et,bCreate,bTempMode);
		if((StringHelper.compare(strDEFieldName,GG_CARD.FIELD_ZWPJ,true)==0)
				&&(StringHelper.compare(strRule,"DEFAULT",true)==0))
			return onTestValueRule_ZWPJ_Default(et,bCreate,bTempMode);
		if((StringHelper.compare(strDEFieldName,GG_CARD.FIELD_ZN,true)==0)
				&&(StringHelper.compare(strRule,"DEFAULT",true)==0))
			return onTestValueRule_ZN_Default(et,bCreate,bTempMode);
		if((StringHelper.compare(strDEFieldName,GG_CARD.FIELD_GRBQ,true)==0)
				&&(StringHelper.compare(strRule,"DEFAULT",true)==0))
			return onTestValueRule_GRBQ_Default(et,bCreate,bTempMode);
		if((StringHelper.compare(strDEFieldName,GG_CARD.FIELD_ENABLE,true)==0)
				&&(StringHelper.compare(strRule,"DEFAULT",true)==0))
			return onTestValueRule_Enable_Default(et,bCreate,bTempMode);
	
		return super.onTestValueRule( strDEFieldName, strRule, et,bCreate, bTempMode);
	}

	/**
	 * 判断值规则[补贴津贴][默认规则]
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据模式
	 * @param bTempMode 是否为临时数据模式
	 * @return
	 * @throws Exception
	 */
	protected String onTestValueRule_BTJT_Default(IEntity et,boolean bCreate,boolean bTempMode) throws Exception
	{
		try
		{
			if((checkFieldStringLengthRule("BTJT", et, bTempMode,null,false,100,true,"内容长度必须小于等于[100]")))
				return null;
			return "内容长度必须小于等于[100]";
		}
		catch(Exception ex)
		{
			return ex.getMessage();
		}
	}
	
	/**
	 * 判断值规则[到岗时间][默认规则]
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据模式
	 * @param bTempMode 是否为临时数据模式
	 * @return
	 * @throws Exception
	 */
	protected String onTestValueRule_DGSJ_Default(IEntity et,boolean bCreate,boolean bTempMode) throws Exception
	{
		return null;
	}
	
	/**
	 * 判断值规则[职能-房地产][默认规则]
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据模式
	 * @param bTempMode 是否为临时数据模式
	 * @return
	 * @throws Exception
	 */
	protected String onTestValueRule_Zn_fdc_Default(IEntity et,boolean bCreate,boolean bTempMode) throws Exception
	{
		try
		{
			if((checkFieldStringLengthRule("ZN_FDC", et, bTempMode,null,false,200,true,"内容长度必须小于等于[200]")))
				return null;
			return "内容长度必须小于等于[200]";
		}
		catch(Exception ex)
		{
			return ex.getMessage();
		}
	}
	
	/**
	 * 判断值规则[公司/单位][默认规则]
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据模式
	 * @param bTempMode 是否为临时数据模式
	 * @return
	 * @throws Exception
	 */
	protected String onTestValueRule_GG_WORKName_Default(IEntity et,boolean bCreate,boolean bTempMode) throws Exception
	{
		try
		{
			if((checkFieldStringLengthRule("GG_WORKNAME", et, bTempMode,null,false,200,true,"内容长度必须小于等于[200]")))
				return null;
			return "内容长度必须小于等于[200]";
		}
		catch(Exception ex)
		{
			return ex.getMessage();
		}
	}
	
	/**
	 * 判断值规则[推荐时间][默认规则]
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据模式
	 * @param bTempMode 是否为临时数据模式
	 * @return
	 * @throws Exception
	 */
	protected String onTestValueRule_TJSJ_Default(IEntity et,boolean bCreate,boolean bTempMode) throws Exception
	{
		return null;
	}
	
	/**
	 * 判断值规则[姓名][默认规则]
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据模式
	 * @param bTempMode 是否为临时数据模式
	 * @return
	 * @throws Exception
	 */
	protected String onTestValueRule_XM_Default(IEntity et,boolean bCreate,boolean bTempMode) throws Exception
	{
		try
		{
			if((checkFieldStringLengthRule("XM", et, bTempMode,null,false,20,true,"内容长度必须小于等于[20]")))
				return null;
			return "内容长度必须小于等于[20]";
		}
		catch(Exception ex)
		{
			return ex.getMessage();
		}
	}
	
	/**
	 * 判断值规则[已推荐企业][默认规则]
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据模式
	 * @param bTempMode 是否为临时数据模式
	 * @return
	 * @throws Exception
	 */
	protected String onTestValueRule_YTJQY_Default(IEntity et,boolean bCreate,boolean bTempMode) throws Exception
	{
		try
		{
			if((checkFieldStringLengthRule("YTJQY", et, bTempMode,null,false,100,true,"内容长度必须小于等于[100]")))
				return null;
			return "内容长度必须小于等于[100]";
		}
		catch(Exception ex)
		{
			return ex.getMessage();
		}
	}
	
	/**
	 * 判断值规则[职能-金融银行][默认规则]
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据模式
	 * @param bTempMode 是否为临时数据模式
	 * @return
	 * @throws Exception
	 */
	protected String onTestValueRule_Zn_jryh_Default(IEntity et,boolean bCreate,boolean bTempMode) throws Exception
	{
		try
		{
			if((checkFieldStringLengthRule("ZN_JRYH", et, bTempMode,null,false,200,true,"内容长度必须小于等于[200]")))
				return null;
			return "内容长度必须小于等于[200]";
		}
		catch(Exception ex)
		{
			return ex.getMessage();
		}
	}
	
	/**
	 * 判断值规则[推荐岗位所在城市][默认规则]
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据模式
	 * @param bTempMode 是否为临时数据模式
	 * @return
	 * @throws Exception
	 */
	protected String onTestValueRule_TJGWSZCS_Default(IEntity et,boolean bCreate,boolean bTempMode) throws Exception
	{
		try
		{
			if((checkFieldStringLengthRule("TJGWSZCS", et, bTempMode,null,false,100,true,"内容长度必须小于等于[100]")))
				return null;
			return "内容长度必须小于等于[100]";
		}
		catch(Exception ex)
		{
			return ex.getMessage();
		}
	}
	
	/**
	 * 判断值规则[照片][默认规则]
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据模式
	 * @param bTempMode 是否为临时数据模式
	 * @return
	 * @throws Exception
	 */
	protected String onTestValueRule_ZP_Default(IEntity et,boolean bCreate,boolean bTempMode) throws Exception
	{
		try
		{
			if((checkFieldStringLengthRule("ZP", et, bTempMode,null,false,100,true,"内容长度必须小于等于[100]")))
				return null;
			return "内容长度必须小于等于[100]";
		}
		catch(Exception ex)
		{
			return ex.getMessage();
		}
	}
	
	/**
	 * 判断值规则[更新时间][默认规则]
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据模式
	 * @param bTempMode 是否为临时数据模式
	 * @return
	 * @throws Exception
	 */
	protected String onTestValueRule_UpdateDate_Default(IEntity et,boolean bCreate,boolean bTempMode) throws Exception
	{
		return null;
	}
	
	/**
	 * 判断值规则[职能-商业零售][默认规则]
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据模式
	 * @param bTempMode 是否为临时数据模式
	 * @return
	 * @throws Exception
	 */
	protected String onTestValueRule_Zn_syls_Default(IEntity et,boolean bCreate,boolean bTempMode) throws Exception
	{
		try
		{
			if((checkFieldStringLengthRule("ZN_SYLS", et, bTempMode,null,false,200,true,"内容长度必须小于等于[200]")))
				return null;
			return "内容长度必须小于等于[200]";
		}
		catch(Exception ex)
		{
			return ex.getMessage();
		}
	}
	
	/**
	 * 判断值规则[行业][默认规则]
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据模式
	 * @param bTempMode 是否为临时数据模式
	 * @return
	 * @throws Exception
	 */
	protected String onTestValueRule_HY_Default(IEntity et,boolean bCreate,boolean bTempMode) throws Exception
	{
		try
		{
			if((checkFieldStringLengthRule("HY", et, bTempMode,null,false,200,true,"内容长度必须小于等于[200]")))
				return null;
			return "内容长度必须小于等于[200]";
		}
		catch(Exception ex)
		{
			return ex.getMessage();
		}
	}
	
	/**
	 * 判断值规则[年龄][默认规则]
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据模式
	 * @param bTempMode 是否为临时数据模式
	 * @return
	 * @throws Exception
	 */
	protected String onTestValueRule_NL_Default(IEntity et,boolean bCreate,boolean bTempMode) throws Exception
	{
		return null;
	}
	
	/**
	 * 判断值规则[证件号][默认规则]
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据模式
	 * @param bTempMode 是否为临时数据模式
	 * @return
	 * @throws Exception
	 */
	protected String onTestValueRule_ZJH_Default(IEntity et,boolean bCreate,boolean bTempMode) throws Exception
	{
		try
		{
			if((checkFieldStringLengthRule("ZJH", et, bTempMode,null,false,40,true,"内容长度必须小于等于[40]")))
				return null;
			return "内容长度必须小于等于[40]";
		}
		catch(Exception ex)
		{
			return ex.getMessage();
		}
	}
	
	/**
	 * 判断值规则[求职状态][默认规则]
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据模式
	 * @param bTempMode 是否为临时数据模式
	 * @return
	 * @throws Exception
	 */
	protected String onTestValueRule_QZZT_Default(IEntity et,boolean bCreate,boolean bTempMode) throws Exception
	{
		try
		{
			if((checkFieldStringLengthRule("QZZT", et, bTempMode,null,false,20,true,"内容长度必须小于等于[20]")))
				return null;
			return "内容长度必须小于等于[20]";
		}
		catch(Exception ex)
		{
			return ex.getMessage();
		}
	}
	
	/**
	 * 判断值规则[政治面貌][默认规则]
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据模式
	 * @param bTempMode 是否为临时数据模式
	 * @return
	 * @throws Exception
	 */
	protected String onTestValueRule_ZZMM_Default(IEntity et,boolean bCreate,boolean bTempMode) throws Exception
	{
		try
		{
			if((checkFieldStringLengthRule("ZZMM", et, bTempMode,null,false,20,true,"内容长度必须小于等于[20]")))
				return null;
			return "内容长度必须小于等于[20]";
		}
		catch(Exception ex)
		{
			return ex.getMessage();
		}
	}
	
	/**
	 * 判断值规则[性别][默认规则]
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据模式
	 * @param bTempMode 是否为临时数据模式
	 * @return
	 * @throws Exception
	 */
	protected String onTestValueRule_XB_Default(IEntity et,boolean bCreate,boolean bTempMode) throws Exception
	{
		try
		{
			if((checkFieldStringLengthRule("XB", et, bTempMode,null,false,5,true,"内容长度必须小于等于[5]")))
				return null;
			return "内容长度必须小于等于[5]";
		}
		catch(Exception ex)
		{
			return ex.getMessage();
		}
	}
	
	/**
	 * 判断值规则[职能-机械制造][默认规则]
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据模式
	 * @param bTempMode 是否为临时数据模式
	 * @return
	 * @throws Exception
	 */
	protected String onTestValueRule_Zn_jxzz_Default(IEntity et,boolean bCreate,boolean bTempMode) throws Exception
	{
		try
		{
			if((checkFieldStringLengthRule("ZN_JXZZ", et, bTempMode,null,false,200,true,"内容长度必须小于等于[200]")))
				return null;
			return "内容长度必须小于等于[200]";
		}
		catch(Exception ex)
		{
			return ex.getMessage();
		}
	}
	
	/**
	 * 判断值规则[工作年限][默认规则]
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据模式
	 * @param bTempMode 是否为临时数据模式
	 * @return
	 * @throws Exception
	 */
	protected String onTestValueRule_GZNX_Default(IEntity et,boolean bCreate,boolean bTempMode) throws Exception
	{
		return null;
	}
	
	/**
	 * 判断值规则[婚姻状态][默认规则]
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据模式
	 * @param bTempMode 是否为临时数据模式
	 * @return
	 * @throws Exception
	 */
	protected String onTestValueRule_HYZT_Default(IEntity et,boolean bCreate,boolean bTempMode) throws Exception
	{
		try
		{
			if((checkFieldStringLengthRule("HYZT", et, bTempMode,null,false,60,true,"内容长度必须小于等于[60]")))
				return null;
			return "内容长度必须小于等于[60]";
		}
		catch(Exception ex)
		{
			return ex.getMessage();
		}
	}
	
	/**
	 * 判断值规则[职能-互联网][默认规则]
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据模式
	 * @param bTempMode 是否为临时数据模式
	 * @return
	 * @throws Exception
	 */
	protected String onTestValueRule_Zn_hlw_Default(IEntity et,boolean bCreate,boolean bTempMode) throws Exception
	{
		try
		{
			if((checkFieldStringLengthRule("ZN_HLW", et, bTempMode,null,false,200,true,"内容长度必须小于等于[200]")))
				return null;
			return "内容长度必须小于等于[200]";
		}
		catch(Exception ex)
		{
			return ex.getMessage();
		}
	}
	
	/**
	 * 判断值规则[个人主页][默认规则]
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据模式
	 * @param bTempMode 是否为临时数据模式
	 * @return
	 * @throws Exception
	 */
	protected String onTestValueRule_GRZY_Default(IEntity et,boolean bCreate,boolean bTempMode) throws Exception
	{
		try
		{
			if((checkFieldStringLengthRule("GRZY", et, bTempMode,null,false,100,true,"内容长度必须小于等于[100]")))
				return null;
			return "内容长度必须小于等于[100]";
		}
		catch(Exception ex)
		{
			return ex.getMessage();
		}
	}
	
	/**
	 * 判断值规则[名称][默认规则]
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据模式
	 * @param bTempMode 是否为临时数据模式
	 * @return
	 * @throws Exception
	 */
	protected String onTestValueRule_GG_CARDName_Default(IEntity et,boolean bCreate,boolean bTempMode) throws Exception
	{
		try
		{
			if((checkFieldStringLengthRule("GG_CARDNAME", et, bTempMode,null,false,200,true,"内容长度必须小于等于[200]")))
				return null;
			return "内容长度必须小于等于[200]";
		}
		catch(Exception ex)
		{
			return ex.getMessage();
		}
	}
	
	/**
	 * 判断值规则[第一学历][默认规则]
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据模式
	 * @param bTempMode 是否为临时数据模式
	 * @return
	 * @throws Exception
	 */
	protected String onTestValueRule_ZGXL_Default(IEntity et,boolean bCreate,boolean bTempMode) throws Exception
	{
		try
		{
			if((checkFieldStringLengthRule("ZGXL", et, bTempMode,null,false,60,true,"内容长度必须小于等于[60]")))
				return null;
			return "内容长度必须小于等于[60]";
		}
		catch(Exception ex)
		{
			return ex.getMessage();
		}
	}
	
	/**
	 * 判断值规则[其他联系方式][默认规则]
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据模式
	 * @param bTempMode 是否为临时数据模式
	 * @return
	 * @throws Exception
	 */
	protected String onTestValueRule_QTLXFS_Default(IEntity et,boolean bCreate,boolean bTempMode) throws Exception
	{
		try
		{
			if((checkFieldStringLengthRule("QTLXFS", et, bTempMode,null,false,60,true,"内容长度必须小于等于[60]")))
				return null;
			return "内容长度必须小于等于[60]";
		}
		catch(Exception ex)
		{
			return ex.getMessage();
		}
	}
	
	/**
	 * 判断值规则[社交账号][默认规则]
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据模式
	 * @param bTempMode 是否为临时数据模式
	 * @return
	 * @throws Exception
	 */
	protected String onTestValueRule_SJZH_Default(IEntity et,boolean bCreate,boolean bTempMode) throws Exception
	{
		try
		{
			if((checkFieldStringLengthRule("SJZH", et, bTempMode,null,false,60,true,"内容长度必须小于等于[60]")))
				return null;
			return "内容长度必须小于等于[60]";
		}
		catch(Exception ex)
		{
			return ex.getMessage();
		}
	}
	
	/**
	 * 判断值规则[目前年收入][默认规则]
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据模式
	 * @param bTempMode 是否为临时数据模式
	 * @return
	 * @throws Exception
	 */
	protected String onTestValueRule_MQNSR_Default(IEntity et,boolean bCreate,boolean bTempMode) throws Exception
	{
		try
		{
			if((checkFieldStringLengthRule("MQNSR", et, bTempMode,null,false,100,true,"内容长度必须小于等于[100]")))
				return null;
			return "内容长度必须小于等于[100]";
		}
		catch(Exception ex)
		{
			return ex.getMessage();
		}
	}
	
	/**
	 * 判断值规则[籍贯][默认规则]
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据模式
	 * @param bTempMode 是否为临时数据模式
	 * @return
	 * @throws Exception
	 */
	protected String onTestValueRule_HKGJ_Default(IEntity et,boolean bCreate,boolean bTempMode) throws Exception
	{
		try
		{
			if((checkFieldStringLengthRule("HKGJ", et, bTempMode,null,false,100,true,"内容长度必须小于等于[100]")))
				return null;
			return "内容长度必须小于等于[100]";
		}
		catch(Exception ex)
		{
			return ex.getMessage();
		}
	}
	
	/**
	 * 判断值规则[期望月薪][默认规则]
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据模式
	 * @param bTempMode 是否为临时数据模式
	 * @return
	 * @throws Exception
	 */
	protected String onTestValueRule_QWNX_Default(IEntity et,boolean bCreate,boolean bTempMode) throws Exception
	{
		try
		{
			if((checkFieldStringLengthRule("QWNX", et, bTempMode,null,false,100,true,"内容长度必须小于等于[100]")))
				return null;
			return "内容长度必须小于等于[100]";
		}
		catch(Exception ex)
		{
			return ex.getMessage();
		}
	}
	
	/**
	 * 判断值规则[奖金佣金][默认规则]
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据模式
	 * @param bTempMode 是否为临时数据模式
	 * @return
	 * @throws Exception
	 */
	protected String onTestValueRule_JJYJ_Default(IEntity et,boolean bCreate,boolean bTempMode) throws Exception
	{
		try
		{
			if((checkFieldStringLengthRule("JJYJ", et, bTempMode,null,false,100,true,"内容长度必须小于等于[100]")))
				return null;
			return "内容长度必须小于等于[100]";
		}
		catch(Exception ex)
		{
			return ex.getMessage();
		}
	}
	
	/**
	 * 判断值规则[职能-生物医药][默认规则]
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据模式
	 * @param bTempMode 是否为临时数据模式
	 * @return
	 * @throws Exception
	 */
	protected String onTestValueRule_Zn_swyy_Default(IEntity et,boolean bCreate,boolean bTempMode) throws Exception
	{
		try
		{
			if((checkFieldStringLengthRule("ZN_SWYY", et, bTempMode,null,false,200,true,"内容长度必须小于等于[200]")))
				return null;
			return "内容长度必须小于等于[200]";
		}
		catch(Exception ex)
		{
			return ex.getMessage();
		}
	}
	
	/**
	 * 判断值规则[家庭住址][默认规则]
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据模式
	 * @param bTempMode 是否为临时数据模式
	 * @return
	 * @throws Exception
	 */
	protected String onTestValueRule_JTZZ_Default(IEntity et,boolean bCreate,boolean bTempMode) throws Exception
	{
		try
		{
			if((checkFieldStringLengthRule("JTZZ", et, bTempMode,null,false,100,true,"内容长度必须小于等于[100]")))
				return null;
			return "内容长度必须小于等于[100]";
		}
		catch(Exception ex)
		{
			return ex.getMessage();
		}
	}
	
	/**
	 * 判断值规则[工作类型][默认规则]
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据模式
	 * @param bTempMode 是否为临时数据模式
	 * @return
	 * @throws Exception
	 */
	protected String onTestValueRule_GZLX_Default(IEntity et,boolean bCreate,boolean bTempMode) throws Exception
	{
		try
		{
			if((checkFieldStringLengthRule("GZLX", et, bTempMode,null,false,20,true,"内容长度必须小于等于[20]")))
				return null;
			return "内容长度必须小于等于[20]";
		}
		catch(Exception ex)
		{
			return ex.getMessage();
		}
	}
	
	/**
	 * 判断值规则[手机][默认规则]
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据模式
	 * @param bTempMode 是否为临时数据模式
	 * @return
	 * @throws Exception
	 */
	protected String onTestValueRule_SJ_Default(IEntity et,boolean bCreate,boolean bTempMode) throws Exception
	{
		try
		{
			if((checkFieldStringLengthRule("SJ", et, bTempMode,null,false,30,true,"内容长度必须小于等于[30]")))
				return null;
			return "内容长度必须小于等于[30]";
		}
		catch(Exception ex)
		{
			return ex.getMessage();
		}
	}
	
	/**
	 * 判断值规则[建立时间][默认规则]
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据模式
	 * @param bTempMode 是否为临时数据模式
	 * @return
	 * @throws Exception
	 */
	protected String onTestValueRule_CreateDate_Default(IEntity et,boolean bCreate,boolean bTempMode) throws Exception
	{
		return null;
	}
	
	/**
	 * 判断值规则[开始工作年份][默认规则]
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据模式
	 * @param bTempMode 是否为临时数据模式
	 * @return
	 * @throws Exception
	 */
	protected String onTestValueRule_KSGZNF_Default(IEntity et,boolean bCreate,boolean bTempMode) throws Exception
	{
		return null;
	}
	
	/**
	 * 判断值规则[建立人][默认规则]
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据模式
	 * @param bTempMode 是否为临时数据模式
	 * @return
	 * @throws Exception
	 */
	protected String onTestValueRule_CreateMan_Default(IEntity et,boolean bCreate,boolean bTempMode) throws Exception
	{
		try
		{
			if((checkFieldStringLengthRule("CREATEMAN", et, bTempMode,null,false,60,true,"内容长度必须小于等于[60]")))
				return null;
			return "内容长度必须小于等于[60]";
		}
		catch(Exception ex)
		{
			return ex.getMessage();
		}
	}
	
	/**
	 * 判断值规则[身高][默认规则]
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据模式
	 * @param bTempMode 是否为临时数据模式
	 * @return
	 * @throws Exception
	 */
	protected String onTestValueRule_SG_Default(IEntity et,boolean bCreate,boolean bTempMode) throws Exception
	{
		return null;
	}
	
	/**
	 * 判断值规则[信息卡标识][默认规则]
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据模式
	 * @param bTempMode 是否为临时数据模式
	 * @return
	 * @throws Exception
	 */
	protected String onTestValueRule_GG_CARDId_Default(IEntity et,boolean bCreate,boolean bTempMode) throws Exception
	{
		try
		{
			if((checkFieldStringLengthRule("GG_CARDID", et, bTempMode,null,false,100,true,"内容长度必须小于等于[100]")))
				return null;
			return "内容长度必须小于等于[100]";
		}
		catch(Exception ex)
		{
			return ex.getMessage();
		}
	}
	
	/**
	 * 判断值规则[基本工资][默认规则]
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据模式
	 * @param bTempMode 是否为临时数据模式
	 * @return
	 * @throws Exception
	 */
	protected String onTestValueRule_JBGZ_Default(IEntity et,boolean bCreate,boolean bTempMode) throws Exception
	{
		try
		{
			if((checkFieldStringLengthRule("JBGZ", et, bTempMode,null,false,100,true,"内容长度必须小于等于[100]")))
				return null;
			return "内容长度必须小于等于[100]";
		}
		catch(Exception ex)
		{
			return ex.getMessage();
		}
	}
	
	/**
	 * 判断值规则[更新人][默认规则]
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据模式
	 * @param bTempMode 是否为临时数据模式
	 * @return
	 * @throws Exception
	 */
	protected String onTestValueRule_UpdateMan_Default(IEntity et,boolean bCreate,boolean bTempMode) throws Exception
	{
		try
		{
			if((checkFieldStringLengthRule("UPDATEMAN", et, bTempMode,null,false,60,true,"内容长度必须小于等于[60]")))
				return null;
			return "内容长度必须小于等于[60]";
		}
		catch(Exception ex)
		{
			return ex.getMessage();
		}
	}
	
	/**
	 * 判断值规则[居住地区][默认规则]
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据模式
	 * @param bTempMode 是否为临时数据模式
	 * @return
	 * @throws Exception
	 */
	protected String onTestValueRule_ZD_Default(IEntity et,boolean bCreate,boolean bTempMode) throws Exception
	{
		try
		{
			if((checkFieldStringLengthRule("ZD", et, bTempMode,null,false,100,true,"内容长度必须小于等于[100]")))
				return null;
			return "内容长度必须小于等于[100]";
		}
		catch(Exception ex)
		{
			return ex.getMessage();
		}
	}
	
	/**
	 * 判断值规则[地点][默认规则]
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据模式
	 * @param bTempMode 是否为临时数据模式
	 * @return
	 * @throws Exception
	 */
	protected String onTestValueRule_DD_Default(IEntity et,boolean bCreate,boolean bTempMode) throws Exception
	{
		try
		{
			if((checkFieldStringLengthRule("DD", et, bTempMode,null,false,100,true,"内容长度必须小于等于[100]")))
				return null;
			return "内容长度必须小于等于[100]";
		}
		catch(Exception ex)
		{
			return ex.getMessage();
		}
	}
	
	/**
	 * 判断值规则[股权收益][默认规则]
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据模式
	 * @param bTempMode 是否为临时数据模式
	 * @return
	 * @throws Exception
	 */
	protected String onTestValueRule_GQSY_Default(IEntity et,boolean bCreate,boolean bTempMode) throws Exception
	{
		try
		{
			if((checkFieldStringLengthRule("GQSY", et, bTempMode,null,false,100,true,"内容长度必须小于等于[100]")))
				return null;
			return "内容长度必须小于等于[100]";
		}
		catch(Exception ex)
		{
			return ex.getMessage();
		}
	}
	
	/**
	 * 判断值规则[邮箱][默认规则]
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据模式
	 * @param bTempMode 是否为临时数据模式
	 * @return
	 * @throws Exception
	 */
	protected String onTestValueRule_YX_Default(IEntity et,boolean bCreate,boolean bTempMode) throws Exception
	{
		try
		{
			if((checkFieldStringLengthRule("YX", et, bTempMode,null,false,60,true,"内容长度必须小于等于[60]")))
				return null;
			return "内容长度必须小于等于[60]";
		}
		catch(Exception ex)
		{
			return ex.getMessage();
		}
	}
	
	/**
	 * 判断值规则[出生日期][默认规则]
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据模式
	 * @param bTempMode 是否为临时数据模式
	 * @return
	 * @throws Exception
	 */
	protected String onTestValueRule_CSRQ_Default(IEntity et,boolean bCreate,boolean bTempMode) throws Exception
	{
		return null;
	}
	
	/**
	 * 判断值规则[自我评价][默认规则]
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据模式
	 * @param bTempMode 是否为临时数据模式
	 * @return
	 * @throws Exception
	 */
	protected String onTestValueRule_ZWPJ_Default(IEntity et,boolean bCreate,boolean bTempMode) throws Exception
	{
		try
		{
			if((checkFieldStringLengthRule("ZWPJ", et, bTempMode,null,false,1000,true,"内容长度必须小于等于[1000]")))
				return null;
			return "内容长度必须小于等于[1000]";
		}
		catch(Exception ex)
		{
			return ex.getMessage();
		}
	}
	
	/**
	 * 判断值规则[职能类别][默认规则]
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据模式
	 * @param bTempMode 是否为临时数据模式
	 * @return
	 * @throws Exception
	 */
	protected String onTestValueRule_ZN_Default(IEntity et,boolean bCreate,boolean bTempMode) throws Exception
	{
		try
		{
			if((checkFieldStringLengthRule("ZN", et, bTempMode,null,false,500,true,"内容长度必须小于等于[500]")))
				return null;
			return "内容长度必须小于等于[500]";
		}
		catch(Exception ex)
		{
			return ex.getMessage();
		}
	}
	
	/**
	 * 判断值规则[个人标签][默认规则]
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据模式
	 * @param bTempMode 是否为临时数据模式
	 * @return
	 * @throws Exception
	 */
	protected String onTestValueRule_GRBQ_Default(IEntity et,boolean bCreate,boolean bTempMode) throws Exception
	{
		try
		{
			if((checkFieldStringLengthRule("GRBQ", et, bTempMode,null,false,100,true,"内容长度必须小于等于[100]")))
				return null;
			return "内容长度必须小于等于[100]";
		}
		catch(Exception ex)
		{
			return ex.getMessage();
		}
	}
	
	/**
	 * 判断值规则[逻辑有效标志][默认规则]
	 * @param et 当前数据对象
	 * @param bCreate 是否为新建数据模式
	 * @param bTempMode 是否为临时数据模式
	 * @return
	 * @throws Exception
	 */
	protected String onTestValueRule_Enable_Default(IEntity et,boolean bCreate,boolean bTempMode) throws Exception
	{
		return null;
	}
	


/* (non-Javadoc)
 * @see net.ibizsys.paas.service.ServiceBase#onMergeChild(java.lang.String, java.lang.String, net.ibizsys.paas.entity.IEntity)
 */
@Override
protected boolean onMergeChild(String strChildType, String strTypeParam, GG_CARD et) throws Exception{
	boolean bRet = false;
	if(super.onMergeChild( strChildType, strTypeParam,  et))
		bRet = true;
	return bRet;
}



/**
 * 更新父数据
 * @param et
 * @throws Exception
 */
@Override
protected void onUpdateParent(GG_CARD et)throws Exception{
	super.onUpdateParent(et);
}


}